diff --git a/omp4py/core/parser/interactive.py b/omp4py/core/parser/interactive.py new file mode 100644 index 0000000..7635e30 --- /dev/null +++ b/omp4py/core/parser/interactive.py @@ -0,0 +1,214 @@ +from __future__ import annotations +from curses import raw +from omp4py.core.parser.source_view import SourceView + +import ast as pyast +import dataclasses +import enum +import json +import traceback +import typing +import argparse +from pathlib import Path + +from .openmp_parser import Tree + +from . import tree +from .parser import _parse, preprocesor + +if typing.TYPE_CHECKING: + from collections.abc import Generator + from typing import Any + + +def read_interactive() -> Generator[str]: + """Reads a string from the user interactively simulating a prompt.""" + try: + while True: + try: + user_input = input(">>> ") + if user_input.startswith("#"): + continue + elif user_input.endswith("\\"): + user_input = user_input[:-1] + "\n" + while True: + more_input = input("... ") + if more_input.startswith("#"): + continue + elif more_input.endswith("\\"): + user_input += more_input[:-1] + "\n" + else: + user_input += more_input + break + yield user_input + except KeyboardInterrupt: + print() + except EOFError: + print() + return + + +def ast_to_json(node: Any, sv: SourceView, expand_ast: bool = False, **kwargs) -> str: + """Serialize the given AST as JSON for debugging.""" + # Utility function + def span_from_pyast(obj: pyast.AST) -> str | None: + if not hasattr(obj, "lineno"): + return "???" + lineno = typing.cast("int", obj.lineno) + end_lineno = typing.cast("int", getattr(obj, "end_lineno", lineno)) + col_offset = typing.cast("int", getattr(obj, "col_offset", 0)) + end_col_offset = typing.cast("int", getattr(obj, "end_col_offset", col_offset)) + span = tree.Span( + lineno=lineno, + offset=col_offset, + end_lineno=end_lineno, + end_offset=end_col_offset, + ) + return f'{span.lineno}:{span.offset}-{span.end_lineno}:{span.end_offset} ==> <{sv.source_text(span)}>' + + # Recursive function + def node_to_json(obj: Any) -> Any: + # Spans are shown with a compact representation and which parts of the code point to + if isinstance(obj, tree.Span): + return f'{obj.lineno}:{obj.offset}-{obj.end_lineno}:{obj.end_offset} ==> <{sv.source_text(obj)}>' + + # Python code + if isinstance(obj, pyast.AST): + # If not allowed, just print the original code + if not expand_ast: + return pyast.unparse(obj) + + # Else, serialize + result: dict[str, Any] = {"type": type(obj).__name__} + loc = span_from_pyast(obj) + if loc: + result["span"] = loc + for field, value in pyast.iter_fields(obj): + result[field] = node_to_json(value) + return result + + # Enums for the clause kinds + if isinstance(obj, enum.Enum): + return obj.name + + # Serialize dataclasses + if dataclasses.is_dataclass(obj) and not isinstance(obj, type): + result = {"type": type(obj).__name__} + for f in dataclasses.fields(obj): + if not f.init: + continue + result[f.name] = node_to_json(getattr(obj, f.name)) + return result + + # Recursive calls for each element in the list/dict + if isinstance(obj, list): + return [node_to_json(v) for v in obj] + if isinstance(obj, dict): + return {k: node_to_json(v) for k, v in obj.items()} + + if isinstance(obj, Tree): + return { + obj.data: { + "position": node_to_json(sv.meta2span(obj.meta)), + "content": [node_to_json(c) for c in obj.children], + }, + } + + # Fallback: see if json.dumps() can handle it + return obj + + return json.dumps(node_to_json(node), **kwargs) + + +def run_interactive_parser() -> None: + # To simulate a complete code + prefix = """\ +from omp4py import * + +@omp +def pi(n: int) -> float: + w = 1.0 / n + pi_value = 0.0 + + with omp(""" + suffix = """): + for i in range(n): + local = (i + 0.5) * w + pi_value += 4.0 / (1.0 + local * local) + + return pi_value * w + +print(pi(1_000_000)) +""" + + for user_input in read_interactive(): + try: + raw_source = ( + f'"{user_input}"' + if len(user_input.splitlines()) == 1 + else f'"""{user_input}"""' + ) + + # Format complete code + complete_code = prefix + raw_source + suffix + lines = complete_code.splitlines() + + # Find the directive's position for the span + start = complete_code.index(raw_source) + before = complete_code[:start] + before_lines = before.splitlines() + start_line = len(before_lines) # 1-based + start_col = len(before_lines[-1]) # 0-based + + after_start = start + len(raw_source) + end_lines = complete_code[:after_start].splitlines() + end_line = len(end_lines) + end_col = len(end_lines[-1]) + + sv = SourceView( + tree.Span( + lineno=start_line, offset=start_col, + end_lineno=end_line, end_offset=end_col, + ), + "", + lines, + complete_code + ) + + code = preprocesor.parse(raw_source) + + print("==== COMPLETE_CODE ====") + print(complete_code, end="") + print("==== SPAN =============") + print(*sv.annotate(sv.span), end="", sep="") + print("==== AST ==============") + ast = _parse(code, sv) + print(ast_to_json(ast, sv, indent=2, expand_ast=True)) + + except Exception as e: + traceback.print_exception(e) + + +def run_interactive_preprocessor() -> None: + for user_input in read_interactive(): + try: + ast = preprocesor.parse(user_input) + print(user_input) + print(ast) + + except Exception as e: + traceback.print_exception(e) + + +if __name__ == "__main__": + + parser = argparse.ArgumentParser() + parser.add_argument("what", choices=("omp", "pre")) + args = parser.parse_args() + + if args.what == "omp": + run_interactive_parser() + elif args.what == "pre": + run_interactive_preprocessor() + + diff --git a/omp4py/core/parser/openmp.lark b/omp4py/core/parser/openmp.lark new file mode 100644 index 0000000..2090127 --- /dev/null +++ b/omp4py/core/parser/openmp.lark @@ -0,0 +1,1645 @@ +////////////////////////////////////////////////////////////////////////////////// +// // +// To generate the OpenMP parser from this grammar use the following command: // +// // +// python -m lark.tools.standalone openmp.lark \ // +// --out openmp_parser.py --start start \ // +// --lexer contextual --propagate_positions // +// // +////////////////////////////////////////////////////////////////////////////////// + +// ----------------------------------------------------------------------------- +// ---- START ------------------------------------------------------------------ +// ----------------------------------------------------------------------------- + +// data environment directives +start: \ + threadprivate_directive + | declare_reduction_directive + | declare_reduction_directive6 + | declare_induction_directive + | scan_directive + | declare_mapper_directive + | groupprivate_directive + // memory management directives + | allocate_directive + // variant directives + | metadirective_directive + | declare_variant_directive + | dispatch_directive + | declare_simd_directive + | declare_target_directive + // informational and utility directives + | requires_directive + | assume_directive + | nothing_directive + | error_directive + // loop transforming contructs + | fuse_directive + | interchange_directive + | split_directive + | stripe_directive + | tile_directive + | unroll_directive + // parallelism contructs + | parallel_directive + | teams_directive + | simd_directive + | masked_directive + // worksharing contructs + | single_directive + | scope_directive + | sections_directive | section_directive + | workshare_directive + | workdistribute_directive + | for_directive + | distribute_directive + | loop_directive + // tasking constructs + | task_directive + | taskloop_directive + | task_iteration_directive + | taskyield_directive + | taskgraph_directive + // device directives & constructs + | target_data_directive + | target_enter_data_directive + | target_exit_data_directive + | target_directive + | target_update_directive + // interoperability construct + | interop_directive + // synchronization constructs + | critical_directive + | barrier_directive + | taskgroup_directive + | taskwait_directive + | atomic_directive + | flush_directive + | depobj_directive + | ordered_directive + // cancelation constructs + | cancel_directive + | cancellation_point_directive + // ---- combined constructs ---- + | combined_directive + +directive_name: \ + THREADPRIVATE_DIRECTIVE + | DECLARE_REDUCTION_DIRECTIVE + | DECLARE_INDUCTION_DIRECTIVE + | SCAN_DIRECTIVE + | DECLARE_MAPPER_DIRECTIVE + | GROUPPRIVATE_DIRECTIVE + // memory management directives + | ALLOCATE_DIRECTIVE + // variant directives + | METADIRECTIVE_DIRECTIVE + | DECLARE_VARIANT_DIRECTIVE + | DISPATCH_DIRECTIVE + | DECLARE_SIMD_DIRECTIVE + | DECLARE_TARGET_DIRECTIVE + // informational and utility directives + | REQUIRES_DIRECTIVE + | ASSUME_DIRECTIVE + | NOTHING_DIRECTIVE + | ERROR_DIRECTIVE + // loop transforming contructs + | FUSE_DIRECTIVE + | INTERCHANGE_DIRECTIVE + | SPLIT_DIRECTIVE + | STRIPE_DIRECTIVE + | TILE_DIRECTIVE + | UNROLL_DIRECTIVE + // parallelism contructs + | PARALLEL_DIRECTIVE + | TEAMS_DIRECTIVE + | SIMD_DIRECTIVE + | MASKED_DIRECTIVE + // worksharing contructs + | SINGLE_DIRECTIVE + | SCOPE_DIRECTIVE + | SECTIONS_DIRECTIVE + | SECTION_DIRECTIVE + | WORKSHARE_DIRECTIVE + | WORKDISTRIBUTE_DIRECTIVE + | FOR_DIRECTIVE + | DISTRIBUTE_DIRECTIVE + | LOOP_DIRECTIVE + // tasking constructs + | TASK_DIRECTIVE + | TASKLOOP_DIRECTIVE + | TASK_ITERATION_DIRECTIVE + | TASKYIELD_DIRECTIVE + | TASKGRAPH_DIRECTIVE + // device directives & constructs + | TARGET_DATA_DIRECTIVE + | TARGET_ENTER_DATA_DIRECTIVE + | TARGET_EXIT_DATA_DIRECTIVE + | TARGET_DIRECTIVE + | TARGET_UPDATE_DIRECTIVE + // interoperability construct + | INTEROP_DIRECTIVE + // synchronization constructs + | CRITICAL_DIRECTIVE + | BARRIER_DIRECTIVE + | TASKGROUP_DIRECTIVE + | TASKWAIT_DIRECTIVE + | ATOMIC_DIRECTIVE + | FLUSH_DIRECTIVE + | DEPOBJ_DIRECTIVE + | ORDERED_DIRECTIVE + // cancelation constructs + | CANCEL_DIRECTIVE + | CANCELLATION_POINT_DIRECTIVE + + +// ----------------------------------------------------------------------------- +// ---- COMBINED CONSTRUCTS ---------------------------------------------------- +// ----------------------------------------------------------------------------- + +combined_directive: _combined_directive_name _combined_directive_name+ [combined_clause_list] + +_combined_directive_name: \ + PARALLEL_DIRECTIVE + | TEAMS_DIRECTIVE + | SIMD_DIRECTIVE + | MASKED_DIRECTIVE + // worksharing + | SINGLE_DIRECTIVE + | SECTIONS_DIRECTIVE + | WORKSHARE_DIRECTIVE + | WORKDISTRIBUTE_DIRECTIVE + | FOR_DIRECTIVE + | DISTRIBUTE_DIRECTIVE + | LOOP_DIRECTIVE + // tasking + | TASK_DIRECTIVE + | TASKLOOP_DIRECTIVE + // device + | TARGET_DATA_DIRECTIVE + | TARGET_ENTER_DATA_DIRECTIVE + | TARGET_EXIT_DATA_DIRECTIVE + | TARGET_DIRECTIVE + | TARGET_UPDATE_DIRECTIVE + +combined_clause_list: _combined_clause (","? _combined_clause)* +_combined_clause: \ + allocate_clause + // parallel + | copyin_clause + | default_clause + | firstprivate_clause + | if_clause + | message_clause + | num_threads_clause + | private_clause + | proc_bind_clause + | reduction_clause + | safesync_clause + | severity_clause + | shared_clause + // teams + | num_teams_clause + | thread_limit_clause + // simd + | aligned_clause + | collapse_clause + | induction_clause + | lastprivate_clause + | linear_clause + | nontemporal_clause + | order_clause + | safelen_clause + | simdlen_clause + // masked + | filter_clause + // single + | copyprivate_clause + | nowait_clause + // sections, workshare, workdistribute: nothing new + // for + | ordered_clause + | schedule_clause + // distribute + | dist_schedule_clause + // loop + | bind_clause + // task + | affinity_clause + | depend_clause + | detach_clause + | final_clause + | in_reduction_clause + | mergeable_clause + | priority_clause + | replayable_clause + | threadset_clause + | transparent_clause + | untied_clause + // taskloop + | grainsize_clause + | nogroup_clause + | num_tasks_clause + // target_data + | device_clause + | map_clause + | use_device_ptr_clause + | use_device_addr_clause + // target_enter_data and target_exit_data: nothing new + // target + | defaultmap_clause + | device_type_clause + | has_device_addr_clause + | is_device_ptr_clause + | uses_allocators_clause + // target_update + | from_clause + | to_clause + +// ----------------------------------------------------------------------------- +// ---- DIRECTIVES WITH THEIR CLAUSES ------------------------------------------ +// ----------------------------------------------------------------------------- + +// IMPORTANT: then directive keywords' names must end with ``_DIRECTIVE`` +// and the clauses keywords' names with ``_CLAUSE``. +// This convention is used by the error system. + +// +// ---- DATA ENVIRONMENT DIRECTIVES ---- +// + +// ---- threadprivate ---- +THREADPRIVATE_DIRECTIVE: "threadprivate" +threadprivate_directive: THREADPRIVATE_DIRECTIVE "(" var_list ")" + + +// ---- declare_reduction ---- +DECLARE_REDUCTION_DIRECTIVE: "declare_reduction" | /declare\s+reduction/ +declare_reduction_directive6: DECLARE_REDUCTION_DIRECTIVE "(" reduction_op ":" type_list ")" _declare_reduction_clause_list +declare_reduction_directive: DECLARE_REDUCTION_DIRECTIVE "(" reduction_op ":" type_list ":" py_stmt ")" [initializer_clause] +// Here combiner() is required, so there's only 3 possibilities +_declare_reduction_clause_list: \ + combiner_clause + | combiner_clause ","? initializer_clause + | initializer_clause ","? combiner_clause + +COMBINER_CLAUSE: "combiner" // required, unique +combiner_clause: COMBINER_CLAUSE "(" [directive_name ":"] py_stmt ")" +INITIALIZER_CLAUSE: "initializer" // unique +initializer_clause: INITIALIZER_CLAUSE "(" [directive_name ":"] py_stmt ")" + + +// ---- declare_induction ---- +// NOTE: original allowed "(item, item)", but the Pythonic equivalent is "tuple[item, item]". +DECLARE_INDUCTION_DIRECTIVE: "declare_induction" +declare_induction_directive: DECLARE_INDUCTION_DIRECTIVE "(" induction_op ":" type_list ")" _declare_induction_clause_list +_declare_induction_clause_list: collector_clause ","? inductor_clause | inductor_clause ","? collector_clause + +INDUCTOR_CLAUSE: "inductor" // unique, required +inductor_clause: INDUCTOR_CLAUSE "(" [directive_name ":"] py_stmt ")" +COLLECTOR_CLAUSE: "collector" // unique, required +collector_clause: COLLECTOR_CLAUSE "(" [directive_name ":"] py_expr ")" + + +// ---- scan ---- +SCAN_DIRECTIVE: "scan" +scan_directive: SCAN_DIRECTIVE _scan_clauses +_scan_clauses: exclusive_clause | inclusive_clause | init_complete_clause + +EXCLUSIVE_CLAUSE: "exclusive" // innermost-leaf, unique +exclusive_clause: EXCLUSIVE_CLAUSE "(" [directive_name ":"] var_list ")" +INCLUSIVE_CLAUSE: "inclusive" // innermost-lead, unique +inclusive_clause: INCLUSIVE_CLAUSE "(" [directive_name ":"] var_list ")" +INIT_COMPLETE_CLAUSE: "init_complete" // innermost-lead, unique +init_complete_clause: INIT_COMPLETE_CLAUSE ["(" [directive_name ":"] py_expr ")"] + + +// ---- declare_mapper ---- +// NOTE: mimic Python variable declaration +DECLARE_MAPPER_DIRECTIVE: "declare_mapper" | /declare\s+mapper/ +declare_mapper_directive: DECLARE_MAPPER_DIRECTIVE "(" [IDENTIFIER ":"] IDENTIFIER ":" py_type ")" map_clause+ + + +// ---- grouprivate ---- +GROUPPRIVATE_DIRECTIVE: "groupprivate" +groupprivate_directive: GROUPPRIVATE_DIRECTIVE [device_type_clause] + +DEVICE_TYPE_CLAUSE: "device_type" // unique +device_type_clause: DEVICE_TYPE_CLAUSE "(" [directive_name ":"] device_type_kind ")" +device_type_kind: (HOST | NOHOST | ANY) -> name +HOST : "host" +NOHOST : "nohost" +ANY : "any" + + +// +// ---- MEMORY MANAGEMENT DIRECTIVES ---- +// + +// ---- allocate ---- +// TODO: does not make sense in Python +ALLOCATE_DIRECTIVE: "allocate" +allocate_directive: ALLOCATE_DIRECTIVE "(" var_list ")" _allocate_clause_list? +_allocate_clause_list: _allocate_clause (","? _allocate_clause)* +_allocate_clause: align_clause | allocator_clause + +ALIGN_CLAUSE: "align" // unique +align_clause: ALIGN_CLAUSE "(" [directive_name ":"] py_expr ")" +ALLOCATOR_CLAUSE: "allocator" // unique +allocator_clause: ALLOCATOR_CLAUSE "(" [directive_name ":"] py_expr ")" + +// TODO: allocators is Fortran only + +// +// ---- VARIANT DIRECTIVES ---- +// + +// ---- metadirective ---- +METADIRECTIVE_DIRECTIVE: "metadirective" +metadirective_directive: METADIRECTIVE_DIRECTIVE _metadirective_clause_list? +_metadirective_clause_list: when_clause (","? when_clause)* [","? otherwise_clause] + +WHEN_CLAUSE: "when" // optional, repeteable +when_clause: WHEN_CLAUSE "(" _when_modifier_list ":" start ")" +// context_selector is required and unique, directive_name is only unique +_when_modifier_list: directive_name | context_selector | directive_name "," context_selector | context_selector "," directive_name + +OTHERWISE_CLAUSE: "otherwise" // unique, ultimate +otherwise_clause: OTHERWISE_CLAUSE ["(" [directive_name ":"] start ")"] + + +// ---- declare_variant ---- +DECLARE_VARIANT_DIRECTIVE: "declare_variant" | /declare\s+variant/ +// Using py_expr here. The standard requires identifier or function type, +// which for Python that could mean a qualified name (module.function) +declare_variant_directive: DECLARE_VARIANT_DIRECTIVE "(" [py_expr ":"] py_expr ")" _declare_variant_clause_list +_declare_variant_clause_list: _declare_variant_clause (","? _declare_variant_clause)* +_declare_variant_clause: adjust_args_clause | append_args_clause | match_clause + +ADJUST_ARGS_CLAUSE: "adjust_args" // optional, repeteable +adjust_args_clause: ADJUST_ARGS_CLAUSE "(" _adjust_args_modifier_list ":" var_list ")" +_adjust_args_modifier_list: adjust_op_name | directive_name "," adjust_op_name | adjust_op_name "," directive_name +adjust_op_name: NEED_DEVICE_PTR | NEED_DEVICE_ADDR | NOTHING // required +NEED_DEVICE_ADDR: "need_device_addr" +NEED_DEVICE_PTR: "need_device_ptr" +NOTHING: "nothing" + +APPEND_ARGS_CLAUSE: "append_args" // unique +append_args_clause: APPEND_ARGS_CLAUSE "(" [directive_name ":"] append_args_arg ")" +append_args_arg: append_op ("," append_op)* + +INTEROP: "interop" +append_op: INTEROP "(" interop_type ("," interop_type)* ")" +interop_type: (TARGET | TARGETSYNC) -> name +TARGET: "target" +TARGETSYNC: "targetsync" + +MATCH_CLAUSE: "match" // unique, required +match_clause: MATCH_CLAUSE "(" [directive_name ":"] context_selector ")" + + +// ---- dispatch ---- +DISPATCH_DIRECTIVE: "dispatch" +dispatch_directive: DISPATCH_DIRECTIVE _dispatch_clause_list? +_dispatch_clause_list: _dispatch_clause (","? _dispatch_clause)* +_dispatch_clause: \ + depend_clause + | device_clause + | interop_clause + | is_device_ptr_clause + | has_device_addr_clause + | nocontext_clause + | novariants_clause + | nowait_clause + +INTEROP_CLAUSE: "interop" +interop_clause: INTEROP_CLAUSE "(" [directive_name ":"] var_list ")" + +IS_DEVICE_PTR_CLAUSE: "is_device_ptr" // innermost-leaf +is_device_ptr_clause: IS_DEVICE_PTR_CLAUSE "(" [directive_name ":"] var_list ")" + +HAS_DEVICE_ADDR_CLAUSE: "has_device_addr" // outermost-leaf +has_device_addr_clause: HAS_DEVICE_ADDR_CLAUSE "(" [directive_name ":"] var_list ")" + +NOCONTEXT_CLAUSE: "nocontext" // unique +nocontext_clause: NOCONTEXT_CLAUSE "(" [directive_name ":"] py_expr ")" + +NOVARIANTS_CLAUSE: "novariants" // unique +novariants_clause: NOVARIANTS_CLAUSE "(" [directive_name ":"] py_expr ")" + + +// ---- declare_simd ---- +DECLARE_SIMD_DIRECTIVE: "declare_simd" | /declare\s+simd/ +// Using py_expr here. The standard requires identifier or function type, +// which for Python that could mean a qualified name (module.function) +declare_simd_directive: DECLARE_SIMD_DIRECTIVE ["(" py_expr ")"] _declare_simd_clause_list? +_declare_simd_clause_list: _declare_simd_clause (","? _declare_simd_clause)* +_declare_simd_clause: aligned_clause | linear_clause | simdlen_clause | uniform_clause | inbranch_clause | notinbranch_clause + +ALIGNED_CLAUSE: "aligned" +aligned_clause: ALIGNED_CLAUSE "(" var_list [":" _aligned_modifier_list] ")" +// alignment is unique and ultimate (because it is post-modified, must be first) +_aligned_modifier_list: alignment_modifier "," directive_name | alignment_modifier | directive_name +alignment_modifier: INTEGER + + +LINEAR_CLAUSE: "linear" // innermost-leaf +linear_clause: LINEAR_CLAUSE "(" var_list [":" _linear_modifier_list] ")" +// step_simple_modifier is exclusive and unique, the rest are unique +_linear_modifier_list: _linear_modifier ("," _linear_modifier)* | step_simple_modifier +_linear_modifier: step_modifier | linear_modifier_name | directive_name +linear_modifier_name: REF|UVAL|VAL +step_simple_modifier: py_expr +REF: "ref" +UVAL: "uval" +VAL: "val" + +SIMDLEN_CLAUSE: "simdlen" // unique +simdlen_clause: SIMDLEN_CLAUSE "(" [directive_name ":"] py_expr ")" + +UNIFORM_CLAUSE: "uniform" +uniform_clause: UNIFORM_CLAUSE "(" [directive_name ":"] var_list ")" + +INBRANCH: "inbranch" +inbranch_clause: INBRANCH ["(" [directive_name ":"] py_expr ")"] + +NOTINBRANCH: "notinbranch" +notinbranch_clause: NOTINBRANCH ["(" [directive_name ":"] py_expr ")"] + + +// ---- declare_target ---- +DECLARE_TARGET_DIRECTIVE: "declare_target" | /declare\s+target/ +declare_target_directive: \ + DECLARE_TARGET_DIRECTIVE "(" var_list ")" -> declare_target_directive + | DECLARE_TARGET_DIRECTIVE _declare_target_clause_list -> declare_target_directive_with_clauses +_declare_target_clause_list: _declare_target_clause (","? _declare_target_clause)* +_declare_target_clause: device_type_clause | enter_clause | indirect_clause | link_clause | local_clause + +ENTER_CLAUSE: "enter" +enter_clause: ENTER_CLAUSE "(" [_enter_modifier_list ":"] var_list ")" +_enter_modifier_list: automap_name | directive_name | automap_name "," directive_name | directive_name "," automap_name +automap_name: AUTOMAP +AUTOMAP: "automap" + +INDIRECT_CLAUSE: "indirect" // unique +indirect_clause: INDIRECT_CLAUSE ["(" [directive_name ":"] py_type ")"] + +LINK_CLAUSE: "link" +link_clause: LINK_CLAUSE "(" [directive_name ":"] var_list ")" + +LOCAL_CLAUSE: "local" +local_clause: LOCAL_CLAUSE "(" [directive_name ":"] var_list ")" + +// +// ---- INFORMATIONAL AND UTILITY DIRECTIVES ---- +// + +// ---- requires ---- +REQUIRES_DIRECTIVE: "requires" +requires_directive: REQUIRES_DIRECTIVE _requires_directive_clause_list +_requires_directive_clause_list: _requires_directive_clause (","? _requires_directive_clause)* +_requires_directive_clause: \ + atomic_default_mem_order_clause + | device_safesync_clause + | dynamic_allocators_clause + | reverse_offload_clause + | self_maps_clause + | unified_address_clause + | unified_shared_memory_clause + +ATOMIC_DEFAULT_MEM_ORDER_CLAUSE: "atomic_default_mem_order" // unique +atomic_default_mem_order_clause: ATOMIC_DEFAULT_MEM_ORDER_CLAUSE "(" [directive_name ":"] atomic_default_mem_order_clause_arg ")" +atomic_default_mem_order_clause_arg: (ACQ_REL | ACQUIRE | RELAXED | SEQ_CST) -> name +ACQ_REL: "acq_rel" +ACQUIRE: "acquire" +RELAXED: "relaxed" +SEQ_CST: "seq_cst" + +DYNAMIC_ALLOCATORS_CLAUSE: "dynamic_allocators" // unique +dynamic_allocators_clause: DYNAMIC_ALLOCATORS_CLAUSE ["(" [directive_name ":"] py_expr ")"] + +REVERSE_OFFLOAD_CLAUSE: "reverse_offload" // unique +reverse_offload_clause: REVERSE_OFFLOAD_CLAUSE ["(" [directive_name ":"] py_expr ")"] + +UNIFIED_ADDRESS_CLAUSE: "unified_address" // unique +unified_address_clause: UNIFIED_ADDRESS_CLAUSE ["(" [directive_name ":"] py_expr ")"] + +UNIFIED_SHARED_MEMORY_CLAUSE: "unified_shared_memory" // unique +unified_shared_memory_clause: UNIFIED_SHARED_MEMORY_CLAUSE ["(" [directive_name ":"] py_expr ")"] + +SELF_MAPS_CLAUSE: "self_maps" // unique +self_maps_clause: SELF_MAPS_CLAUSE ["(" [directive_name ":"] py_expr ")"] + +DEVICE_SAFESYNC_CLAUSE: "device_safesync" // unique +device_safesync_clause: DEVICE_SAFESYNC_CLAUSE ["(" [directive_name ":"] py_expr ")"] + + +// ---- assume ---- +ASSUME_DIRECTIVE: "assume" +assume_directive: ASSUME_DIRECTIVE _assume_clause_list +_assume_clause_list: _assume_clause (","? _assume_clause)* +_assume_clause: \ + absent_clause + | contains_clause + | holds_clause + | no_openmp_clause + | no_openmp_constructs_clause + | no_openmp_routines_clause + | no_parallelism_clause + +ABSENT_CLAUSE: "absent" // unique +absent_clause: ABSENT_CLAUSE "(" [directive_name ":"] directive_list ")" +directive_list: directive_name ("," directive_name)* + +CONTAINS_CLAUSE: "contains" // unique +contains_clause: CONTAINS_CLAUSE "(" [directive_name ":"] directive_list ")" + + +HOLDS_CLAUSE: "holds" // unique +holds_clause: HOLDS_CLAUSE "(" [directive_name ":"] py_expr ")" + +NO_OPENMP_CLAUSE: "no_openmp" // unique +no_openmp_clause: NO_OPENMP_CLAUSE ["(" [directive_name ":"] py_expr ")"] + +NO_OPENMP_CONSTRUCTS_CLAUSE: "no_openmp_constructs" // unique +no_openmp_constructs_clause: NO_OPENMP_CONSTRUCTS_CLAUSE ["(" [directive_name ":"] py_expr ")"] + +NO_OPENMP_ROUTINES_CLAUSE: "no_openmp_routines" // unique +no_openmp_routines_clause: NO_OPENMP_ROUTINES_CLAUSE ["(" [directive_name ":"] py_expr ")"] + +NO_PARALLELISM_CLAUSE: "no_parallelism" // unique +no_parallelism_clause: NO_PARALLELISM_CLAUSE ["(" [directive_name ":"] py_expr ")"] + + +// ---- nothing ---- +NOTHING_DIRECTIVE: "nothing" // optional, repeteable +nothing_directive: NOTHING_DIRECTIVE [apply_clause] + + +// ---- error ---- +ERROR_DIRECTIVE: "error" +error_directive: ERROR_DIRECTIVE _error_clause_list? +_error_clause_list: _error_clause (","? _error_clause)? +_error_clause: at_clause | message_clause | severity_clause + +AT_CLAUSE: "at" // unique +at_clause: AT_CLAUSE "(" [directive_name ":"] at_clause_arg ")" +at_clause_arg: (COMPILATION | EXECUTION) -> name +COMPILATION: "compilation" +EXECUTION: "execution" + +// py_expr here to accept string literals +MESSAGE_CLAUSE: "message" // unique +message_clause: MESSAGE_CLAUSE "(" [directive_name ":"] py_expr ")" + +SEVERITY_CLAUSE: "severity" // unique +severity_clause: SEVERITY_CLAUSE "(" [directive_name ":"] severity_clause_arg ")" +severity_clause_arg: (FATAL | WARNING) -> name +FATAL: "fatal" +WARNING: "warning" + + +// +// ---- LOOP TRANFORMING CONSTRUCTS ---- +// + +// ---- fuse ---- +FUSE_DIRECTIVE: "fuse" +fuse_directive: FUSE_DIRECTIVE (apply_clause | looprange_clause) + +// TODO: In section 6.4.7, the looprange clause does not declare the directive_name_modifier. +LOOPRANGE_CLAUSE: "looprange" // unique +looprange_clause: LOOPRANGE_CLAUSE "(" [directive_name ":"] py_expr "," py_expr ")" + + +// ---- interchange ---- +INTERCHANGE_DIRECTIVE: "interchange" +interchange_directive: INTERCHANGE_DIRECTIVE _interchange_clause_list? +_interchange_clause_list: apply_clause | permutation_clause | apply_clause ","? permutation_clause | permutation_clause ","? apply_clause + +PERMUTATION_CLAUSE: "permutation" // unique +permutation_clause: PERMUTATION_CLAUSE "(" [directive_name ":"] expr_list ")" + + +// ---- reverse ---- +REVERSE_DIRECTIVE: "reverse" +reverse_directive: REVERSE_DIRECTIVE [apply_clause] + + +// ---- split ---- +SPLIT_DIRECTIVE: "split" +split_directive: SPLIT_DIRECTIVE _split_clause_list +_split_clause_list: counts_clause | apply_clause ","? counts_clause | counts_clause ","? apply_clause + +COUNTS_CLAUSE: "counts" // unique, required +counts_clause: COUNTS_CLAUSE "(" [directive_name ":"] expr_list ")" + + +// ---- stripe ---- +STRIPE_DIRECTIVE: "stripe" +stripe_directive: STRIPE_DIRECTIVE _stripe_clause_list +_stripe_clause_list: sizes_clause | apply_clause ","? sizes_clause | sizes_clause ","? apply_clause + +SIZES_CLAUSE: "sizes" // unique, required +sizes_clause: SIZES_CLAUSE "(" [directive_name ":"] expr_list ")" + + +// ---- tile ---- +TILE_DIRECTIVE: "tile" +tile_directive: TILE_DIRECTIVE _tile_clause_list? +_tile_clause_list: sizes_clause | apply_clause ","? sizes_clause | sizes_clause ","? apply_clause + + +// ---- unroll ---- +UNROLL_DIRECTIVE: "unroll" +unroll_directive: UNROLL_DIRECTIVE _unroll_clause_list? +_unroll_clause_list: full_clause | partial_clause | apply_clause + | full_clause ","? apply_clause | apply_clause ","? full_clause + | partial_clause ","? apply_clause | apply_clause ","? partial_clause + +FULL_CLAUSE: "full" // unique +full_clause: FULL_CLAUSE ["(" [directive_name ":"] py_expr ")"] + +PARTIAL_CLAUSE: "partial" // unique +partial_clause: PARTIAL_CLAUSE ["(" [directive_name ":"] py_expr ")"] + + +// +// ---- PARALLELISM CONSTRUCTS ---- +// + +// ---- parallel ---- +PARALLEL_DIRECTIVE: "parallel" +parallel_directive: PARALLEL_DIRECTIVE _parallel_clause_list? +_parallel_clause_list: _parallel_clause (","? _parallel_clause)* +_parallel_clause: \ + allocate_clause + | copyin_clause + | default_clause + | firstprivate_clause + | if_clause + | message_clause + | num_threads_clause + | private_clause + | proc_bind_clause + | reduction_clause + | safesync_clause + | severity_clause + | shared_clause + +COPYIN_CLAUSE: "copyin" // outermost-leaf +copyin_clause: COPYIN_CLAUSE "(" [directive_name ":"] var_list ")" + +NUM_THREADS_CLAUSE: "num_threads" // unique +num_threads_clause: NUM_THREADS_CLAUSE "(" [_num_threads_modifier_list ":"] expr_list ")" +_num_threads_modifier_list: strict_name | directive_name | directive_name "," strict_name | strict_name "," directive_name +strict_name: STRICT +STRICT: "strict" + +PROC_BIND_CLAUSE: "proc_bind" // unique +proc_bind_clause: PROC_BIND_CLAUSE "(" [directive_name ":"] proc_bind_clause_arg ")" +proc_bind_clause_arg: (CLOSE | PRIMARY | SPREAD) -> name +PRIMARY: "primary" +SPREAD: "spread" + +SAFESYNC_CLAUSE: "safesync" // unique +safesync_clause: SAFESYNC_CLAUSE ["(" [directive_name ":"] py_expr ")"] + + +// ---- teams ---- +TEAMS_DIRECTIVE: "teams" +teams_directive: TEAMS_DIRECTIVE _teams_clause_list? +_teams_clause_list: _teams_clause (","? _teams_clause)? +_teams_clause: \ + allocate_clause + | default_clause + | firstprivate_clause + | if_clause + | num_teams_clause + | reduction_clause + | shared_clause + | thread_limit_clause + +NUM_TEAMS_CLAUSE: "num_teams" // unique +num_teams_clause: NUM_TEAMS_CLAUSE "(" [_num_teams_modifier_list ":"] py_expr ")" +// lower_bound is unique and ultimate +_num_teams_modifier_list: directive_name | lower_bound | directive_name "," lower_bound +lower_bound: py_expr + +THREAD_LIMIT_CLAUSE: "thread_limit" // unique +thread_limit_clause: THREAD_LIMIT_CLAUSE "(" [directive_name ":"] py_expr ")" + + +// ---- simd ---- +SIMD_DIRECTIVE: "simd" +simd_directive: SIMD_DIRECTIVE _simd_clause_list? +_simd_clause_list: _simd_clause (","? _simd_clause)? +_simd_clause: \ + aligned_clause + | collapse_clause + | if_clause + | induction_clause + | lastprivate_clause + | linear_clause + | nontemporal_clause + | order_clause + | private_clause + | reduction_clause + | safelen_clause + | simdlen_clause + +NONTEMPORAL_CLAUSE: "nontemporal" // default +nontemporal_clause: NONTEMPORAL_CLAUSE "(" [directive_name ":"] var_list ")" + +ORDER_CLAUSE: "order" // unique +order_clause: ORDER_CLAUSE "(" [_order_modifier_list ":"] CONCURRENT ")" +_order_modifier_list: directive_name | order_modifier_name | directive_name "," order_modifier_name | order_modifier_name "," directive_name +order_modifier_name: REPRODUCIBLE | UNCONSTRAINED +CONCURRENT: "concurrent" +REPRODUCIBLE: "reproducible" +UNCONSTRAINED: "unconstrained" + +SAFELEN_CLAUSE: "safelen" // unique +safelen_clause: SAFELEN_CLAUSE "(" [directive_name ":"] py_expr ")" + + +// ---- masked ---- +MASKED_DIRECTIVE: "masked" +masked_directive: MASKED_DIRECTIVE filter_clause? + +FILTER_CLAUSE: "filter" // unique +filter_clause: FILTER_CLAUSE "(" [directive_name ":"] py_expr ")" + +// +// ---- WORKSHARING CONSTRUCTS ---- +// + +// ---- single ---- +SINGLE_DIRECTIVE: "single" +single_directive: SINGLE_DIRECTIVE _single_clause_list? +_single_clause_list: _single_clause (","? _single_clause)* +_single_clause: \ + allocate_clause + | copyprivate_clause + | firstprivate_clause + | nowait_clause + | private_clause + +COPYPRIVATE_CLAUSE: "copyprivate" // innermost-leaf +copyprivate_clause: COPYPRIVATE_CLAUSE "(" [directive_name ":"] var_list ")" + + +// ---- scope ---- +SCOPE_DIRECTIVE: "scope" +scope_directive: SCOPE_DIRECTIVE _scope_clause_list? +_scope_clause_list: _scope_clause (","? _scope_clause)? +_scope_clause: \ + allocate_clause + | firstprivate_clause + | nowait_clause + | private_clause + | reduction_clause + + +// ---- sections ---- +SECTIONS_DIRECTIVE: "sections" +sections_directive: SECTIONS_DIRECTIVE _sections_clause_list? +_sections_clause_list: _sections_clause (","? _sections_clause)* +_sections_clause: \ + allocate_clause + | firstprivate_clause + | lastprivate_clause + | nowait_clause + | private_clause + | reduction_clause + + +// ---- section ---- +SECTION_DIRECTIVE: "section" +section_directive: SECTION_DIRECTIVE + + +// ---- workshare ---- +WORKSHARE_DIRECTIVE: "workshare" +workshare_directive: WORKSHARE_DIRECTIVE nowait_clause? + + +// ---- workdistribute ---- +WORKDISTRIBUTE_DIRECTIVE: "workdistribute" +workdistribute_directive: WORKDISTRIBUTE_DIRECTIVE + + +// ---- for ---- +FOR_DIRECTIVE: "for" +for_directive: FOR_DIRECTIVE _for_clause_list? +_for_clause_list: _for_clause (","? _for_clause)* +_for_clause: \ + allocate_clause + | collapse_clause + | firstprivate_clause + | induction_clause + | lastprivate_clause + | linear_clause + | nowait_clause + | order_clause + | ordered_clause + | private_clause + | reduction_clause + | schedule_clause + +ORDERED_CLAUSE: "ordered" // unique +ordered_clause: ORDERED_CLAUSE ["(" [directive_name ":"] py_expr ")"] + +SCHEDULE_CLAUSE: "schedule" // unique +schedule_clause: SCHEDULE_CLAUSE "(" [_schedule_modifier_list ":"] schedule_type ["," py_expr] ")" +_schedule_modifier_list: _schedule_modifier ("," _schedule_modifier)* +_schedule_modifier: ordering_modifier_name | chunk_modifier_name | directive_name +ordering_modifier_name: MONOTONIC | NONMONOTONIC +chunk_modifier_name: SIMD +schedule_type: STATIC | DYNAMIC | GUIDED | AUTO | RUNTIME +STATIC : "static" +DYNAMIC : "dynamic" +GUIDED : "guided" +AUTO : "auto" +RUNTIME : "runtime" +MONOTONIC : "monotonic" +NONMONOTONIC : "nonmonotonic" +SIMD : "simd" + + +// ---- distribute ---- +DISTRIBUTE_DIRECTIVE: "distribute" +distribute_directive: DISTRIBUTE_DIRECTIVE _distribute_clause_list? +_distribute_clause_list: _distribute_clause (","? _distribute_clause)? +_distribute_clause: \ + allocate_clause + | collapse_clause + | dist_schedule_clause + | firstprivate_clause + | induction_clause + | lastprivate_clause + | order_clause + | private_clause + +DIST_SCHEDULE_CLAUSE: "dist_schedule" // unique +dist_schedule_clause: DIST_SCHEDULE_CLAUSE "(" [directive_name ":"] STATIC ["," py_expr] ")" + + +// ---- loop ---- +LOOP_DIRECTIVE: "loop" +loop_directive: LOOP_DIRECTIVE _loop_clause_list? +_loop_clause_list: _loop_clause (","? _loop_clause)? +_loop_clause: \ + bind_clause + | collapse_clause + | lastprivate_clause + | order_clause + | private_clause + | reduction_clause + +BIND_CLAUSE: "bind" // unique +bind_clause: BIND_CLAUSE "(" [directive_name ":"] bind_clause_arg ")" +bind_clause_arg: (PARALLEL | TEAMS | THREAD) -> name +PARALLEL: "parallel" +TEAMS: "teams" +THREAD: "thread" + + +// +// ---- TASKING CONSTRUCTS ---- +// + +// ---- task ---- +TASK_DIRECTIVE: "task" +task_directive: TASK_DIRECTIVE _task_clause_list? +_task_clause_list: _task_clause (","? _task_clause)* +_task_clause: \ + affinity_clause + | allocate_clause + | default_clause + | depend_clause + | detach_clause + | final_clause + | firstprivate_clause + | if_clause + | in_reduction_clause + | mergeable_clause + | priority_clause + | private_clause + | replayable_clause + | shared_clause + | threadset_clause + | transparent_clause + | untied_clause + + +// ---- taskloop ---- +TASKLOOP_DIRECTIVE: "taskloop" +taskloop_directive: TASKLOOP_DIRECTIVE _taskloop_clause_list? +_taskloop_clause_list: _taskloop_clause (","? _taskloop_clause)? +_taskloop_clause: \ + allocate_clause + | collapse_clause + | default_clause + | final_clause + | firstprivate_clause + | grainsize_clause + | if_clause + | in_reduction_clause + | induction_clause + | lastprivate_clause + | mergeable_clause + | nogroup_clause + | num_tasks_clause + | priority_clause + | private_clause + | reduction_clause + | replayable_clause + | shared_clause + | threadset_clause + | transparent_clause + | untied_clause + +GRAINSIZE_CLAUSE: "grainsize" // unique +grainsize_clause: GRAINSIZE_CLAUSE "(" [_grainsize_modifier_list ":"] py_expr ")" +_grainsize_modifier_list: strict_name | directive_name | strict_name "," directive_name | directive_name "," strict_name + +NUM_TASKS_CLAUSE: "num_tasks" +num_tasks_clause: NUM_TASKS_CLAUSE "(" [_num_tasks_modifier_list ":"] py_expr ")" +_num_tasks_modifier_list: strict_name | directive_name | strict_name "," directive_name | directive_name "," strict_name + + +// ---- task_iteration ---- +TASK_ITERATION_DIRECTIVE: "task_iteration" +task_iteration_directive: TASK_ITERATION_DIRECTIVE _task_iteration_clause_list +_task_iteration_clause_list: _task_iteration_clause (","? _task_iteration_clause)? +_task_iteration_clause: affinity_clause | depend_clause | if_clause + + +// ---- taskyield ---- +TASKYIELD_DIRECTIVE: "taskyield" +taskyield_directive: TASKYIELD_DIRECTIVE + + +// ---- taskgraph ---- +TASKGRAPH_DIRECTIVE: "taskgraph" +taskgraph_directive: TASKGRAPH_DIRECTIVE _taskgraph_clause_list? +_taskgraph_clause_list: _taskgraph_clause (","? _taskgraph_clause)? +_taskgraph_clause: graph_id_clause | graph_reset_clause | if_clause | nogroup_clause + +// TODO: In section 14.3.1, the graph_id clause does not declare the directive_name_modifier. +GRAPH_ID_CLAUSE: "graph_id" +graph_id_clause: GRAPH_ID_CLAUSE "(" [directive_name ":"] py_expr ")" + +// TODO: In section 14.3.2, the graph_reset clause does not declare the directive_name_modifier. +GRAPH_RESET_CLAUSE: "graph_reset" +graph_reset_clause: GRAPH_RESET_CLAUSE "(" [directive_name ":"] py_expr ")" + + +// +// ---- DEVICE DIRECTIVES & CONSTRUCTS ---- +// + +// ---- target_data ---- +TARGET_DATA_DIRECTIVE: "target_data" | /target\s+data/ +target_data_directive: TARGET_DATA_DIRECTIVE _target_data_clause_list +_target_data_clause_list: _target_data_clause (","? _target_data_clause)? +_target_data_clause: \ + affinity_clause + | allocate_clause + | default_clause + | depend_clause + | detach_clause + | device_clause + | firstprivate_clause + | if_clause + | in_reduction_clause + | map_clause + | mergeable_clause + | nogroup_clause + | nowait_clause + | priority_clause + | private_clause + | shared_clause + | transparent_clause + | use_device_ptr_clause + | use_device_addr_clause + +USE_DEVICE_PTR_CLAUSE: "use_device_ptr" +use_device_ptr_clause: USE_DEVICE_PTR_CLAUSE "(" [directive_name ":"] var_list ")" + +USE_DEVICE_ADDR_CLAUSE: "use_device_addr" +use_device_addr_clause: USE_DEVICE_ADDR_CLAUSE "(" [directive_name ":"] var_list ")" + + +// ---- target_enter_data ---- +TARGET_ENTER_DATA_DIRECTIVE: "target_enter_data" | /target\s+enter\s+data/ +target_enter_data_directive: TARGET_ENTER_DATA_DIRECTIVE _target_enter_data_clause_list? +_target_enter_data_clause_list: _target_enter_data_clause (","? _target_enter_data_clause)? +_target_enter_data_clause: \ + depend_clause + | device_clause + | if_clause + | map_clause + | nowait_clause + | priority_clause + | replayable_clause + + +// ---- target_exit_data ---- +TARGET_EXIT_DATA_DIRECTIVE: "target_exit_data" | /target\s+exit\s+data/ +target_exit_data_directive: TARGET_EXIT_DATA_DIRECTIVE _target_exit_data_clause_list? +_target_exit_data_clause_list: _target_exit_data_clause (","? _target_exit_data_clause)? +_target_exit_data_clause: \ + depend_clause + | device_clause + | if_clause + | map_clause + | nowait_clause + | priority_clause + | replayable_clause + + +// ---- target ---- +TARGET_DIRECTIVE: "target" +target_directive: TARGET_DIRECTIVE _target_clause_list? +_target_clause_list: _target_clause (","? _target_clause)? +_target_clause: \ + allocate_clause + | default_clause + | defaultmap_clause + | depend_clause + | device_clause + | device_type_clause + | firstprivate_clause + | has_device_addr_clause + | if_clause + | in_reduction_clause + | is_device_ptr_clause + | map_clause + | nowait_clause + | private_clause + | priority_clause + | replayable_clause + | thread_limit_clause + | uses_allocators_clause + +DEFAULTMAP_CLAUSE: "defaultmap" // unique +defaultmap_clause: DEFAULTMAP_CLAUSE "(" _defaultmap_arg [":" _defaultmap_modifier_list] ")" +_defaultmap_arg: DEFAULT | FIRSTPRIVATE | FROM | NONE | PRESENT | PRIVATE | SELF | STORAGE | TO | TOFROM +_defaultmap_modifier_list: directive_name | variable_category_name + | directive_name "," variable_category_name | variable_category_name "," directive_name + +USES_ALLOCATORS_CLAUSE: "uses_allocators" +uses_allocators_clause: USES_ALLOCATORS_CLAUSE "(" [_uses_allocator_modifier_list ":"] py_expr ")" +_uses_allocator_modifier_list: _uses_allocator_modifier ("," _uses_allocator_modifier)* +_uses_allocator_modifier: memspace_modifier | traits_modifier | directive_name + + +// ---- target_update ---- +TARGET_UPDATE_DIRECTIVE: "target_update" | /target\s+update/ +target_update_directive: TARGET_UPDATE_DIRECTIVE _target_update_clause_list? +_target_update_clause_list: _target_update_clause (","? _target_update_clause)? +_target_update_clause: \ + depend_clause + | device_clause + | from_clause + | if_clause + | nowait_clause + | priority_clause + | replayable_clause + | to_clause + +TO_CLAUSE: "to" +to_clause: TO_CLAUSE "(" [_to_modifier_list ":"] var_list ")" +_to_modifier_list: _from_modifier ("," _from_modifier)* +_to_modifier: present_name | mapper_modifier | iterator_modifier | directive_name +present_name: PRESENT + +FROM_CLAUSE: "from" +from_clause: FROM_CLAUSE "(" [_from_modifier_list ":"] var_list ")" +_from_modifier_list: _from_modifier ("," _from_modifier)* +_from_modifier: present_name | mapper_modifier | iterator_modifier | directive_name + + +// +// ---- INTEROPERABILITY CONSTRUCT ---- +// + +// ---- interop ---- +INTEROP_DIRECTIVE: "interop" +interop_directive: INTEROP_DIRECTIVE _interop_clause_list +_interop_clause_list: _interop_clause (","? _interop_clause)? +_interop_clause: \ + depend_clause + | destroy_clause + | device_clause + | init_clause + | nowait_clause + | use_clause + +DESTROY_CLAUSE: "destroy" // default +destroy_clause: DESTROY_CLAUSE "(" [directive_name ":"] IDENTIFIER ")" + +INIT_CLAUSE: "init" // innermost-leaf +init_clause: INIT_CLAUSE "(" [_init_modifier_list ":"] IDENTIFIER ")" +_init_modifier_list: _init_modifier ("," _init_modifier)* +// all are unique, except interop_type_modifier, which is repeteable +_init_modifier: interop_type_modifier_name | prefer_type_modifier | depinfo_modifier | directive_name +interop_type_modifier_name: TARGET | TARGETSYNC + +USE_CLAUSE: "use" // default +use_clause: USE_CLAUSE "(" [directive_name ":"] IDENTIFIER ")" + + +// +// ---- SYNCHRONIZATION CONSTRUCT ---- +// + +// ---- critical ---- +CRITICAL_DIRECTIVE: "critical" +critical_directive: CRITICAL_DIRECTIVE ["(" IDENTIFIER ")" [","? hint_clause]] + +HINT_CLAUSE: "hint" // unique +hint_clause: HINT_CLAUSE "(" [directive_name ":"] py_expr ")" + + +// ---- barrier ---- +BARRIER_DIRECTIVE: "barrier" +barrier_directive: BARRIER_DIRECTIVE + + +// ---- taskgroup ---- +TASKGROUP_DIRECTIVE: "taskgroup" +taskgroup_directive: TASKGROUP_DIRECTIVE _taskgroup_clause_list? +_taskgroup_clause_list: _taskgroup_clause (","? _taskgroup_clause)? +_taskgroup_clause: allocate_clause | task_reduction_clause + +TASK_REDUCTION_CLAUSE: "task_reduction" +task_reduction_clause: TASK_REDUCTION_CLAUSE "(" [directive_name ","] reduction_op ":" var_list ")" + + +// ---- taskwait ---- +TASKWAIT_DIRECTIVE: "taskwait" +taskwait_directive: TASKWAIT_DIRECTIVE _taskwait_clause_list? +_taskwait_clause_list: _taskwait_clause (","? _taskwait_clause)? +_taskwait_clause: depend_clause | nowait_clause | replayable_clause + + +// ---- atomic ---- +ATOMIC_DIRECTIVE: "atomic" +atomic_directive: ATOMIC_DIRECTIVE _atomic_clause_list + +// memory order and atomic groups are exclusive, but atomic extended it's not. +// We cannot model this in the grammar because it gives reduction/reduction conflicts. +_atomic_clause_list: _atomic_clause (","? _atomic_clause)* +_atomic_clause: \ + read_clause | atomic_update_clause | write_clause // atomic + | capture_clause | compare_clause | fail_clause | weak_clause // extended atomic + | acq_rel_clause | acquire_clause | relaxed_clause | release_clause | seq_cst_clause // memory order + | memscope_clause | hint_clause + +MEMSCOPE_CLAUSE: "memscope" // unique +memscope_clause: MEMSCOPE_CLAUSE "(" [directive_name ":"] memscope_clause_arg ")" +memscope_clause_arg: (ALL | CGROUP | DEVICE) -> name +CGROUP: "cgroup" +DEVICE: "device" + +READ_CLAUSE: "read" // innermost-leaf, unique +read_clause: READ_CLAUSE ["(" [directive_name ":"] py_expr ")"] + +atomic_update_clause: UPDATE_CLAUSE ["(" [directive_name ":"] py_expr ")"] // innermost-leaf, unique + +WRITE_CLAUSE: "write" // innermost-leaf, unique +write_clause: WRITE_CLAUSE ["(" [directive_name ":"] py_expr ")"] + +CAPTURE_CLAUSE: "capture" // innermost-leaf, unique +capture_clause: CAPTURE_CLAUSE ["(" [directive_name ":"] py_expr ")"] + +COMPARE_CLAUSE: "compare" // innermost-leaf, unique +compare_clause: COMPARE_CLAUSE ["(" [directive_name ":"] py_expr ")"] + +FAIL_CLAUSE: "fail" // innermost-leaf, unique +fail_clause: FAIL_CLAUSE "(" [directive_name ":"] fail_clause_arg ")" +fail_clause_arg: (ACQUIRE | RELAXED | SEQ_CST) -> name + +WEAK_CLAUSE: "weak" // innermost-leaf, unique +weak_clause: WEAK_CLAUSE ["(" [directive_name ":"] py_expr ")"] + +ACQ_REL_CLAUSE: "acq_rel" // unique +acq_rel_clause: ACQ_REL_CLAUSE ["(" [directive_name ":"] py_expr ")"] + +ACQUIRE_CLAUSE: "acquire" // unique +acquire_clause: ACQUIRE_CLAUSE ["(" [directive_name ":"] py_expr ")"] + +RELAXED_CLAUSE: "relaxed" // unique +relaxed_clause: RELAXED_CLAUSE ["(" [directive_name ":"] py_expr ")"] + +RELEASE_CLAUSE: "release" // unique +release_clause: RELEASE_CLAUSE ["(" [directive_name ":"] py_expr ")"] + +SEQ_CST_CLAUSE: "seq_cst" // unique +seq_cst_clause: SEQ_CST_CLAUSE ["(" [directive_name ":"] py_expr ")"] + + +// ---- flush ---- +FLUSH_DIRECTIVE: "flush" +flush_directive: FLUSH_DIRECTIVE [acq_rel_clause | acquire_clause | relaxed_clause | release_clause | seq_cst_clause | memscope_clause] ["(" var_list ")"] + + +// ---- depobj ---- +DEPOBJ_DIRECTIVE: "depobj" +depobj_directive: DEPOBJ_DIRECTIVE "(" IDENTIFIER ")" (destroy_clause | init_clause | depobj_update_clause) + +UPDATE_CLAUSE: "update" // innermost-leaf, unique +depobj_update_clause: UPDATE_CLAUSE "(" [_depobj_update_modifier_list ":"] IDENTIFIER ")" +_depobj_update_modifier_list: directive_name | task_dependence_name + | directive_name "," task_dependence_name | task_dependence_name "," directive_name + + +// ---- ordered ---- +ORDERED_DIRECTIVE: "ordered" +ordered_directive: ORDERED_DIRECTIVE (doacross_clause | _ordered_clause_list?) +_ordered_clause_list: threads_clause | simd_clause | threads_clause ","? simd_clause | simd_clause ","? threads_clause + +DOACROSS_CLAUSE: "doacross" // required +doacross_clause: DOACROSS_CLAUSE "(" _doacross_modifier_list ":" iterator_specifier ")" +_doacross_modifier_list: dependence_type_name | directive_name "," dependence_type_name | dependence_type_name "," directive_name +dependence_type_name: SINK | SOURCE +SINK: "sink" +SOURCE: "source" + +THREADS_CLAUSE: "threads" // innermost-leaf, unique +threads_clause: THREADS_CLAUSE ["(" [directive_name ":"] py_expr ")"] + +SIMD_CLAUSE: "simd" // innermost-leaf, unique +simd_clause: SIMD_CLAUSE ["(" [directive_name ":"] py_expr ")"] + + +// +// ---- CANCELLATION CONSTRUCT ---- +// + +// ---- cancel ---- +// TODO: directive_name_modifier might be wrong here +CANCEL_DIRECTIVE: "cancel" +cancel_directive: CANCEL_DIRECTIVE [directive_name ":"] _construct_type_clause [","? if_clause] +_construct_type_clause: PARALLEL_DIRECTIVE | SECTIONS_DIRECTIVE | TASKGROUP_DIRECTIVE | FOR_DIRECTIVE + + +// ---- cancellation_point ---- +CANCELLATION_POINT_DIRECTIVE: "cancellation_point" | /cancellation\s+point/ +cancellation_point_directive: CANCELLATION_POINT_DIRECTIVE [directive_name ":"] _construct_type_clause + + +// ----------------------------------------------------------------------------- +// ---- COMMON CLAUSES --------------------------------------------------------- +// ----------------------------------------------------------------------------- + +// TODO: reduce-reduce conflict because both directive_name and _apply_directive share the same tokens. +// This clause cannot be part of a combined construct (see _combined_clause), so this should be fine. +APPLY_CLAUSE: "apply" // optional +apply_clause: APPLY_CLAUSE "(" [_apply_modifier_list ":"] apply_clause_arg ")" +//_apply_modifier_list: directive_name | loop_modifier | loop_modifier "," directive_name | directive_name "," loop_modifier +_apply_modifier_list: loop_modifier +apply_clause_arg: _apply_directive ("," _apply_directive)* +_apply_directive: FUSE_DIRECTIVE | INTERCHANGE_DIRECTIVE | NOTHING_DIRECTIVE | REVERSE_DIRECTIVE | SPLIT_DIRECTIVE | STRIPE_DIRECTIVE | TILE_DIRECTIVE | UNROLL_DIRECTIVE + + +DEPEND_CLAUSE: "depend" +depend_clause: DEPEND_CLAUSE "(" [_depend_modifier_list ":"] expr_list ")" +// Each modifier is unique, but may be declared in any order +_depend_modifier_list: _depend_modifier ("," _depend_modifier)* +_depend_modifier: task_dependence_name | iterator_modifier | directive_name +task_dependence_name: DEPOBJ | IN | INOUT | INOUTSET | MUTEXINOUTSET | OUT +DEPOBJ: "depobj" +IN: "in" +INOUT: "inout" +INOUTSET: "inoutset" +MUTEXINOUTSET: "mutexinoutset" +OUT: "out" + + +DEVICE_CLAUSE: "device" // unique +device_clause: DEVICE_CLAUSE "(" [_device_modifier_list ":"] py_expr ")" +_device_modifier_list: device_modifier_name | directive_name + | device_modifier_name "," directive_name | directive_name "," device_modifier_name +device_modifier_name: ANCESTOR | DEVICE_NUM +ANCESTOR: "ancestor" +DEVICE_NUM: "device_num" + + +DEFAULT_CLAUSE: "default" // unique +default_clause: DEFAULT_CLAUSE "(" (NONE | SHARED | FIRSTPRIVATE | PRIVATE) [":" _default_modifier] ")" +_default_modifier: directive_name | variable_category_name + | directive_name "," variable_category_name | variable_category_name "," directive_name +variable_category_name: ALL | ALLOCATABLE | POINTER | SCALAR | AGGREGATE +NONE: "none" +SHARED: "shared" +FIRSTPRIVATE: "firstprivate" +PRIVATE: "private" +AGGREGATE: "aggregate" +ALL: "all" +ALLOCATABLE: "allocatable" +POINTER: "pointer" +SCALAR: "scalar" + + +PRIVATE_CLAUSE: "private" // innermost-leaf +private_clause: PRIVATE_CLAUSE "(" [directive_name ":"] var_list ")" + + +IF_CLAUSE: "if" // unique +if_clause: IF_CLAUSE "(" [directive_name ":"] py_expr ")" + + +FIRSTPRIVATE_CLAUSE: "firstprivate" +firstprivate_clause: FIRSTPRIVATE_CLAUSE "(" [_firstprivate_modifier ":"] var_list ")" +_firstprivate_modifier: directive_name | saved_name | directive_name "," saved_name | saved_name "," directive_name +saved_name: SAVED +SAVED: "saved" + + +REDUCTION_CLAUSE: "reduction" +reduction_clause: REDUCTION_CLAUSE "(" [_reduction_modifier_list ","] reduction_op ":" var_list ")" +_reduction_modifier_list: _reduction_modifier ("," _reduction_modifier)* +_reduction_modifier: reduction_modifier_name | original_modifier | directive_name +reduction_modifier_name: INSCAN|TASK|DEFAULT +DEFAULT: "default" +INSCAN: "inscan" +TASK: "task" + + +INDUCTION_CLAUSE: "induction" +induction_clause: INDUCTION_CLAUSE "(" _induction_modifier_list "," induction_op ":" var_list ")" +// induction_op is required and ultimate, step_modifier is required +_induction_modifier_list: \ + step_modifier + // permutations of two + | directive_name "," step_modifier + | step_modifier "," directive_name + | induction_modifier_name "," step_modifier + | step_modifier "," induction_modifier_name + // permutations of three + | directive_name "," step_modifier "," induction_modifier_name + | directive_name "," induction_modifier_name "," step_modifier + | induction_modifier_name "," directive_name "," step_modifier + | induction_modifier_name "," step_modifier "," directive_name + | step_modifier "," induction_modifier_name "," directive_name + | step_modifier "," directive_name "," induction_modifier_name + +induction_modifier_name: RELAXED|STRICT + + +SHARED_CLAUSE: "shared" +shared_clause: SHARED_CLAUSE "(" [directive_name ":"] var_list ")" + + +COLLAPSE_CLAUSE: "collapse" // unique +collapse_clause: COLLAPSE_CLAUSE "(" [directive_name ":"] py_expr ")" + + +LASTPRIVATE_CLAUSE: "lastprivate" +lastprivate_clause: LASTPRIVATE_CLAUSE "(" [_lastprivate_modifier_list ":"] var_list ")" +_lastprivate_modifier_list: conditional_name | directive_name + | directive_name "," conditional_name | conditional_name "," directive_name +conditional_name: CONDITIONAL +CONDITIONAL: "conditional" + + +// TODO: allocators make no sense in Python +ALLOCATE_CLAUSE: "allocate" +allocate_clause: ALLOCATE_CLAUSE "(" [_allocate_modifier_list ":"] var_list ")" +// allocator_simple_modifier is exclusive +_allocate_modifier_list: _allocate_modifier ("," _allocate_modifier)* | allocator_simple_modifier +_allocate_modifier: allocator_modifier | align_modifier | directive_name +allocator_simple_modifier: py_expr + + +NOWAIT_CLAUSE: "nowait" // outermost-leaf, unique +nowait_clause: NOWAIT_CLAUSE ["(" [directive_name ":"] py_expr ")"] + + +FINAL_CLAUSE: "final" // unique +final_clause: FINAL_CLAUSE "(" [directive_name ":"] py_expr ")" + + +MERGEABLE_CLAUSE: "mergeable" // unique +mergeable_clause: MERGEABLE_CLAUSE ["(" [directive_name ":"] py_expr ")"] + + +UNTIED_CLAUSE: "untied" // unique +untied_clause: UNTIED_CLAUSE ["(" [directive_name ":"] py_expr ")"] + + +AFFINITY_CLAUSE: "affinity" +affinity_clause: AFFINITY_CLAUSE "(" [_affinity_modifier_list ":"] var_list ")" +_affinity_modifier_list: iterator_modifier | directive_name | directive_name "," iterator_modifier | iterator_modifier "," directive_name + + +DETACH_CLAUSE: "detach" // innermost-leaf, unique +detach_clause: DETACH_CLAUSE "(" [directive_name ":"] IDENTIFIER ")" + + +IN_REDUCTION_CLAUSE: "in_reduction" +in_reduction_clause: IN_REDUCTION_CLAUSE "(" [directive_name ","] reduction_op ":" var_list ")" + + +PRIORITY_CLAUSE: "priority" // unique +priority_clause: PRIORITY_CLAUSE "(" [directive_name ":"] py_expr ")" + + +REPLAYABLE_CLAUSE: "replayable" // default +replayable_clause: REPLAYABLE_CLAUSE ["(" [directive_name ":"] py_expr ")"] + + +THREADSET_CLAUSE: "threadset" // unique +threadset_clause: THREADSET_CLAUSE "(" [directive_name ":"] threadset_clause_arg ")" +threadset_clause_arg: (OMP_TEAM | OMP_POOL) -> name +OMP_POOL: "omp_pool" +OMP_TEAM: "omp_team" + + +TRANSPARENT_CLAUSE: "transparent" // unique +transparent_clause: TRANSPARENT_CLAUSE ["(" [directive_name ":"] py_expr ")"] + + +NOGROUP_CLAUSE: "nogroup" // innermost-leaf, unique +nogroup_clause: NOGROUP_CLAUSE ["(" [directive_name ":"] py_expr ")"] + + +MAP_CLAUSE: "map" +map_clause: MAP_CLAUSE "(" [[_map_modifier_list ","] map_type_name ":"] var_list ")" +_map_modifier_list: _map_modifier ("," _map_modifier)* +_map_modifier: \ + always_modifier_name + | close_modifier_name + | present_modifier_name + | self_modifier_name + | delete_modifier_name + | ref_modifier_name + | mapper_modifier + | iterator_modifier + | directive_name +map_type_name: FROM | STORAGE | TO | TOFROM +ref_modifier_name: REF_PTEE|REF_PTR|REF_PTR_PTEE +always_modifier_name: ALWAYS +close_modifier_name: CLOSE +present_modifier_name: PRESENT +self_modifier_name: SELF +delete_modifier_name: DELETE +ALWAYS: "always" +CLOSE: "close" +PRESENT: "present" +SELF: "self" +REF_PTEE: "ref_ptee" +REF_PTR: "ref_ptr" +REF_PTR_PTEE: "ref_ptr_ptee" +DELETE: "delete" +FROM: "from" +STORAGE: "storage" +TO: "to" +TOFROM: "tofrom" + + +// ----------------------------------------------------------------------------- +// ---- MODIFIERS -------------------------------------------------------------- +// ----------------------------------------------------------------------------- + +// +// ---- PYTHON ---- +// + +// TODO: Handle strings correctly, "foo('test[')" is a valid expression +// but this gives an error because '[' is unbalanced. +// This can be handled in the preprocesor, by adding the notion of a nested string. + +// The lower priority is important, +// otherwise clauses taking python code and with optional modifiers, +// the lexer will always start by assuming code, +// thus making the modifiers impossible to provide. +PY_CODE_OUT.-1 : /[^(){}\[\]:,]+/ +PY_CODE_IN.-1 : /[^(){}\[\]]+/ +py_code_out : (PY_CODE_OUT | "(" py_code_in? ")" | "{" py_code_in? "}" | "[" py_code_in? "]")+ +py_code_in : (PY_CODE_IN | "(" py_code_in? ")" | "{" py_code_in? "}" | "[" py_code_in? "]")+ + +py_expr: py_code_out +py_type: py_code_out -> py_expr +py_stmt: py_code_out + + +// +// ---- LISTS ---- +// + +var_list : IDENTIFIER ("," IDENTIFIER)* +expr_list : py_expr ("," py_expr)* +type_list : py_type ("," py_type)* -> expr_list +stmt_list : py_stmt ("," py_stmt)* + + +// +// ---- OTHER OPENMP DEFINITIONS ---- +// + +// reduction_op is ultimate and required +reduction_op: IDENTIFIER | PLUS | MULT | BITWISE_AND | BITWISE_OR | BITWISE_XOR | LOGIC_AND | LOGIC_OR | MAX | MIN +induction_op: IDENTIFIER | PLUS | MULT +PLUS : "+" +MULT : "*" +BITWISE_AND : "&" +BITWISE_OR : "|" +BITWISE_XOR : "^" +LOGIC_AND : "and" // NOTE: original was "&&" +LOGIC_OR : "or" // NOTE: original was "||" +MAX : "max" +MIN : "min" + + +ORIGINAL: "original" +original_modifier: ORIGINAL "(" (DEFAULT | PRIVATE | SHARED) ")" + + +ITERATOR: "iterator" +iterator_modifier: ITERATOR "(" iterator_specifier ("," iterator_specifier)* ")" +iterator_specifier: IDENTIFIER "=" py_expr ":" py_expr [":" py_expr] +// TODO: py_type will eat the '=': +// _iterator_specifier: IDENTIFIER [":" py_type] "=" py_expr ":" py_expr [":" py_expr] + + +STEP: "step" +step_modifier: STEP "(" py_expr ")" + +ALLOCATOR: "allocator" +allocator_modifier: ALLOCATOR "(" py_expr ")" + +ALIGN: "align" +align_modifier: ALIGN "(" py_expr ")" + +MAPPER: "mapper" +mapper_modifier: MAPPER "(" IDENTIFIER ")" + +MEMSPACE: "memspace" +memspace_modifier: MEMSPACE "(" py_expr ")" + +TRAITS: "traits" +traits_modifier: TRAITS "(" py_expr ")" + +depinfo_modifier: (IN | INOUT| INOUTSET | MUTEXINOUTSET | OUT) "(" var_list ")" + +loop_modifier: (FUSED | GRID | IDENTITY | INTERCHANGED | INTRATILE | OFFSETS | REVERSED | SPLIT | UNROLLED) ["(" expr_list ")"] +FUSED: "fused" +GRID: "grid" +IDENTITY: "identity" +INTERCHANGED: "interchanged" +INTRATILE: "intratile" +OFFSETS: "offsets" +REVERSED: "reversed" +SPLIT: "split" +UNROLLED: "unrolled" + +PREFER_TYPE: "prefer_type" +prefer_type_modifier: PREFER_TYPE "(" preference_specification ("," preference_specification )* ")" +preference_specification: "{" (fr_selector|attr_selector) ("," (fr_selector|attr_selector))* "}" | IDENTIFIER +// expression list to allow a list of string literals +fr_selector: FR "(" IDENTIFIER ")" +attr_selector: ATTR "(" expr_list ")" +FR: "fr" +ATTR: "attr" + +// TODO: context_selector +context_selector: stmt_list +// context_selector: trait_set_selector ("," trait_set_selector)* +// trait_set_selector: IDENTIFIER "=" "{" trait_selector ("," trait_selector)* "}" +// trait_selector: IDENTIFIER ["(" [trait_score ":"] trait_property ("," trait_property)* ")"] +// trait_score: "score" "(" py_expr ")" +// trait_property: IDENTIFIER | py_expr | IDENTIFIER ["(" trait_property_extension ("," trait_property_extension)*] // TODO: clause + +// ----------------------------------------------------------------------------- +// ---- TOKENS ----------------------------------------------------------------- +// ----------------------------------------------------------------------------- + +_WHITESPACE: /\s+/ +%ignore _WHITESPACE + +// Python integer definitions +// https://docs.python.org/3/reference/lexical_analysis.html#grammar-token-python-grammar-integer +_DIGIT : "0".."9" +_NON_ZERO_DIGIT : "1".."9" +_BIN_DIGIT : "0" | "1" +_OCT_DIGIT : "0".."7" +_HEX_DIGIT : _DIGIT | "a".."f" | "A".."F" + +_DEC_INTEGER : _NON_ZERO_DIGIT ("_"? _DIGIT)* +_BIN_INTEGER : "0" ("b" | "B") ("_"? _BIN_DIGIT)+ +_OCT_INTEGER : "0" ("o" | "O") ("_"? _OCT_DIGIT)+ +_HEX_INTEGER : "0" ("x" | "X") ("_"? _HEX_DIGIT)+ +_ZERO_INTEGER : "0"+ ("_"? "0")* + +INTEGER: _DEC_INTEGER | _BIN_INTEGER | _OCT_INTEGER | _HEX_INTEGER | _ZERO_INTEGER + +// Python identifier definitions +// https://docs.python.org/3/reference/lexical_analysis.html#names-identifiers-and-keywords +IDENTIFIER: /[^\W\d]\w*/ + diff --git a/omp4py/core/parser/openmp_parser.py b/omp4py/core/parser/openmp_parser.py new file mode 100644 index 0000000..6232703 --- /dev/null +++ b/omp4py/core/parser/openmp_parser.py @@ -0,0 +1,3572 @@ +# The file was automatically generated by Lark v1.3.1 +__version__ = "1.3.1" + +# +# +# Lark Stand-alone Generator Tool +# ---------------------------------- +# Generates a stand-alone LALR(1) parser +# +# Git: https://github.com/erezsh/lark +# Author: Erez Shinan (erezshin@gmail.com) +# +# +# >>> LICENSE +# +# This tool and its generated code use a separate license from Lark, +# and are subject to the terms of the Mozilla Public License, v. 2.0. +# If a copy of the MPL was not distributed with this +# file, You can obtain one at https://mozilla.org/MPL/2.0/. +# +# If you wish to purchase a commercial license for this tool and its +# generated code, you may contact me via email or otherwise. +# +# If MPL2 is incompatible with your free or open-source project, +# contact me and we'll work it out. +# +# + +from copy import deepcopy +from abc import ABC, abstractmethod +from types import ModuleType +from typing import ( + TypeVar, Generic, Type, Tuple, List, Dict, Iterator, Collection, Callable, Optional, FrozenSet, Any, + Union, Iterable, IO, TYPE_CHECKING, overload, Sequence, + Pattern as REPattern, ClassVar, Set, Mapping +) + + +class LarkError(Exception): + pass + + +class ConfigurationError(LarkError, ValueError): + pass + + +def assert_config(value, options: Collection, msg='Got %r, expected one of %s'): + if value not in options: + raise ConfigurationError(msg % (value, options)) + + +class GrammarError(LarkError): + pass + + +class ParseError(LarkError): + pass + + +class LexError(LarkError): + pass + +T = TypeVar('T') + +class UnexpectedInput(LarkError): + #-- + line: int + column: int + pos_in_stream = None + state: Any + _terminals_by_name = None + interactive_parser: 'InteractiveParser' + + def get_context(self, text: str, span: int=40) -> str: + #-- + pos = self.pos_in_stream or 0 + start = max(pos - span, 0) + end = pos + span + if not isinstance(text, bytes): + before = text[start:pos].rsplit('\n', 1)[-1] + after = text[pos:end].split('\n', 1)[0] + return before + after + '\n' + ' ' * len(before.expandtabs()) + '^\n' + else: + before = text[start:pos].rsplit(b'\n', 1)[-1] + after = text[pos:end].split(b'\n', 1)[0] + return (before + after + b'\n' + b' ' * len(before.expandtabs()) + b'^\n').decode("ascii", "backslashreplace") + + def match_examples(self, parse_fn: 'Callable[[str], Tree]', + examples: Union[Mapping[T, Iterable[str]], Iterable[Tuple[T, Iterable[str]]]], + token_type_match_fallback: bool=False, + use_accepts: bool=True + ) -> Optional[T]: + #-- + assert self.state is not None, "Not supported for this exception" + + if isinstance(examples, Mapping): + examples = examples.items() + + candidate = (None, False) + for i, (label, example) in enumerate(examples): + assert not isinstance(example, str), "Expecting a list" + + for j, malformed in enumerate(example): + try: + parse_fn(malformed) + except UnexpectedInput as ut: + if ut.state == self.state: + if ( + use_accepts + and isinstance(self, UnexpectedToken) + and isinstance(ut, UnexpectedToken) + and ut.accepts != self.accepts + ): + logger.debug("Different accepts with same state[%d]: %s != %s at example [%s][%s]" % + (self.state, self.accepts, ut.accepts, i, j)) + continue + if ( + isinstance(self, (UnexpectedToken, UnexpectedEOF)) + and isinstance(ut, (UnexpectedToken, UnexpectedEOF)) + ): + if ut.token == self.token: ## + + logger.debug("Exact Match at example [%s][%s]" % (i, j)) + return label + + if token_type_match_fallback: + ## + + if (ut.token.type == self.token.type) and not candidate[-1]: + logger.debug("Token Type Fallback at example [%s][%s]" % (i, j)) + candidate = label, True + + if candidate[0] is None: + logger.debug("Same State match at example [%s][%s]" % (i, j)) + candidate = label, False + + return candidate[0] + + def _format_expected(self, expected): + if self._terminals_by_name: + d = self._terminals_by_name + expected = [d[t_name].user_repr() if t_name in d else t_name for t_name in expected] + return "Expected one of: \n\t* %s\n" % '\n\t* '.join(expected) + + +class UnexpectedEOF(ParseError, UnexpectedInput): + #-- + expected: 'List[Token]' + + def __init__(self, expected, state=None, terminals_by_name=None): + super(UnexpectedEOF, self).__init__() + + self.expected = expected + self.state = state + from .lexer import Token + self.token = Token("", "") ## + + self.pos_in_stream = -1 + self.line = -1 + self.column = -1 + self._terminals_by_name = terminals_by_name + + + def __str__(self): + message = "Unexpected end-of-input. " + message += self._format_expected(self.expected) + return message + + +class UnexpectedCharacters(LexError, UnexpectedInput): + #-- + + allowed: Set[str] + considered_tokens: Set[Any] + + def __init__(self, seq, lex_pos, line, column, allowed=None, considered_tokens=None, state=None, token_history=None, + terminals_by_name=None, considered_rules=None): + super(UnexpectedCharacters, self).__init__() + + ## + + self.line = line + self.column = column + self.pos_in_stream = lex_pos + self.state = state + self._terminals_by_name = terminals_by_name + + self.allowed = allowed + self.considered_tokens = considered_tokens + self.considered_rules = considered_rules + self.token_history = token_history + + if isinstance(seq, bytes): + self.char = seq[lex_pos:lex_pos + 1].decode("ascii", "backslashreplace") + else: + self.char = seq[lex_pos] + self._context = self.get_context(seq) + + + def __str__(self): + message = "No terminal matches '%s' in the current parser context, at line %d col %d" % (self.char, self.line, self.column) + message += '\n\n' + self._context + if self.allowed: + message += self._format_expected(self.allowed) + if self.token_history: + message += '\nPrevious tokens: %s\n' % ', '.join(repr(t) for t in self.token_history) + return message + + +class UnexpectedToken(ParseError, UnexpectedInput): + #-- + + expected: Set[str] + considered_rules: Set[str] + + def __init__(self, token, expected, considered_rules=None, state=None, interactive_parser=None, terminals_by_name=None, token_history=None): + super(UnexpectedToken, self).__init__() + + ## + + self.line = getattr(token, 'line', '?') + self.column = getattr(token, 'column', '?') + self.pos_in_stream = getattr(token, 'start_pos', None) + self.state = state + + self.token = token + self.expected = expected ## + + self._accepts = NO_VALUE + self.considered_rules = considered_rules + self.interactive_parser = interactive_parser + self._terminals_by_name = terminals_by_name + self.token_history = token_history + + + @property + def accepts(self) -> Set[str]: + if self._accepts is NO_VALUE: + self._accepts = self.interactive_parser and self.interactive_parser.accepts() + return self._accepts + + def __str__(self): + message = ("Unexpected token %r at line %s, column %s.\n%s" + % (self.token, self.line, self.column, self._format_expected(self.accepts or self.expected))) + if self.token_history: + message += "Previous tokens: %r\n" % self.token_history + + return message + + + +class VisitError(LarkError): + #-- + + obj: 'Union[Tree, Token]' + orig_exc: Exception + + def __init__(self, rule, obj, orig_exc): + message = 'Error trying to process rule "%s":\n\n%s' % (rule, orig_exc) + super(VisitError, self).__init__(message) + + self.rule = rule + self.obj = obj + self.orig_exc = orig_exc + + +class MissingVariableError(LarkError): + pass + + +import sys, re +import logging +from dataclasses import dataclass +from typing import Generic, AnyStr + +logger: logging.Logger = logging.getLogger("lark") +logger.addHandler(logging.StreamHandler()) +## + +## + +logger.setLevel(logging.CRITICAL) + + +NO_VALUE = object() + +T = TypeVar("T") + + +def classify(seq: Iterable, key: Optional[Callable] = None, value: Optional[Callable] = None) -> Dict: + d: Dict[Any, Any] = {} + for item in seq: + k = key(item) if (key is not None) else item + v = value(item) if (value is not None) else item + try: + d[k].append(v) + except KeyError: + d[k] = [v] + return d + + +def _deserialize(data: Any, namespace: Dict[str, Any], memo: Dict) -> Any: + if isinstance(data, dict): + if '__type__' in data: ## + + class_ = namespace[data['__type__']] + return class_.deserialize(data, memo) + elif '@' in data: + return memo[data['@']] + return {key:_deserialize(value, namespace, memo) for key, value in data.items()} + elif isinstance(data, list): + return [_deserialize(value, namespace, memo) for value in data] + return data + + +_T = TypeVar("_T", bound="Serialize") + +class Serialize: + #-- + + def memo_serialize(self, types_to_memoize: List) -> Any: + memo = SerializeMemoizer(types_to_memoize) + return self.serialize(memo), memo.serialize() + + def serialize(self, memo = None) -> Dict[str, Any]: + if memo and memo.in_types(self): + return {'@': memo.memoized.get(self)} + + fields = getattr(self, '__serialize_fields__') + res = {f: _serialize(getattr(self, f), memo) for f in fields} + res['__type__'] = type(self).__name__ + if hasattr(self, '_serialize'): + self._serialize(res, memo) + return res + + @classmethod + def deserialize(cls: Type[_T], data: Dict[str, Any], memo: Dict[int, Any]) -> _T: + namespace = getattr(cls, '__serialize_namespace__', []) + namespace = {c.__name__:c for c in namespace} + + fields = getattr(cls, '__serialize_fields__') + + if '@' in data: + return memo[data['@']] + + inst = cls.__new__(cls) + for f in fields: + try: + setattr(inst, f, _deserialize(data[f], namespace, memo)) + except KeyError as e: + raise KeyError("Cannot find key for class", cls, e) + + if hasattr(inst, '_deserialize'): + inst._deserialize() + + return inst + + +class SerializeMemoizer(Serialize): + #-- + + __serialize_fields__ = 'memoized', + + def __init__(self, types_to_memoize: List) -> None: + self.types_to_memoize = tuple(types_to_memoize) + self.memoized = Enumerator() + + def in_types(self, value: Serialize) -> bool: + return isinstance(value, self.types_to_memoize) + + def serialize(self) -> Dict[int, Any]: ## + + return _serialize(self.memoized.reversed(), None) + + @classmethod + def deserialize(cls, data: Dict[int, Any], namespace: Dict[str, Any], memo: Dict[Any, Any]) -> Dict[int, Any]: ## + + return _deserialize(data, namespace, memo) + + +try: + import regex + _has_regex = True +except ImportError: + _has_regex = False + +if sys.version_info >= (3, 11): + import re._parser as sre_parse + import re._constants as sre_constants +else: + import sre_parse + import sre_constants + +categ_pattern = re.compile(r'\\p{[A-Za-z_]+}') + +def get_regexp_width(expr: str) -> Union[Tuple[int, int], List[int]]: + if _has_regex: + ## + + ## + + ## + + regexp_final = re.sub(categ_pattern, 'A', expr) + else: + if re.search(categ_pattern, expr): + raise ImportError('`regex` module must be installed in order to use Unicode categories.', expr) + regexp_final = expr + try: + ## + + return [int(x) for x in sre_parse.parse(regexp_final).getwidth()] + except sre_constants.error: + if not _has_regex: + raise ValueError(expr) + else: + ## + + ## + + c = regex.compile(regexp_final) + ## + + ## + + MAXWIDTH = getattr(sre_parse, "MAXWIDTH", sre_constants.MAXREPEAT) + if c.match('') is None: + ## + + return 1, int(MAXWIDTH) + else: + return 0, int(MAXWIDTH) + + +@dataclass(frozen=True) +class TextSlice(Generic[AnyStr]): + #-- + text: AnyStr + start: int + end: int + + def __post_init__(self): + if not isinstance(self.text, (str, bytes)): + raise TypeError("text must be str or bytes") + + if self.start < 0: + object.__setattr__(self, 'start', self.start + len(self.text)) + assert self.start >=0 + + if self.end is None: + object.__setattr__(self, 'end', len(self.text)) + elif self.end < 0: + object.__setattr__(self, 'end', self.end + len(self.text)) + assert self.end <= len(self.text) + + @classmethod + def cast_from(cls, text: 'TextOrSlice') -> 'TextSlice[AnyStr]': + if isinstance(text, TextSlice): + return text + + return cls(text, 0, len(text)) + + def is_complete_text(self): + return self.start == 0 and self.end == len(self.text) + + def __len__(self): + return self.end - self.start + + def count(self, substr: AnyStr): + return self.text.count(substr, self.start, self.end) + + def rindex(self, substr: AnyStr): + return self.text.rindex(substr, self.start, self.end) + + +TextOrSlice = Union[AnyStr, 'TextSlice[AnyStr]'] +LarkInput = Union[AnyStr, TextSlice[AnyStr], Any] + + + +class Meta: + + empty: bool + line: int + column: int + start_pos: int + end_line: int + end_column: int + end_pos: int + orig_expansion: 'List[TerminalDef]' + match_tree: bool + + def __init__(self): + self.empty = True + + +_Leaf_T = TypeVar("_Leaf_T") +Branch = Union[_Leaf_T, 'Tree[_Leaf_T]'] + + +class Tree(Generic[_Leaf_T]): + #-- + + data: str + children: 'List[Branch[_Leaf_T]]' + + def __init__(self, data: str, children: 'List[Branch[_Leaf_T]]', meta: Optional[Meta]=None) -> None: + self.data = data + self.children = children + self._meta = meta + + @property + def meta(self) -> Meta: + if self._meta is None: + self._meta = Meta() + return self._meta + + def __repr__(self): + return 'Tree(%r, %r)' % (self.data, self.children) + + __match_args__ = ("data", "children") + + def _pretty_label(self): + return self.data + + def _pretty(self, level, indent_str): + yield f'{indent_str*level}{self._pretty_label()}' + if len(self.children) == 1 and not isinstance(self.children[0], Tree): + yield f'\t{self.children[0]}\n' + else: + yield '\n' + for n in self.children: + if isinstance(n, Tree): + yield from n._pretty(level+1, indent_str) + else: + yield f'{indent_str*(level+1)}{n}\n' + + def pretty(self, indent_str: str=' ') -> str: + #-- + return ''.join(self._pretty(0, indent_str)) + + def __rich__(self, parent:Optional['rich.tree.Tree']=None) -> 'rich.tree.Tree': + #-- + return self._rich(parent) + + def _rich(self, parent): + if parent: + tree = parent.add(f'[bold]{self.data}[/bold]') + else: + import rich.tree + tree = rich.tree.Tree(self.data) + + for c in self.children: + if isinstance(c, Tree): + c._rich(tree) + else: + tree.add(f'[green]{c}[/green]') + + return tree + + def __eq__(self, other): + try: + return self.data == other.data and self.children == other.children + except AttributeError: + return False + + def __ne__(self, other): + return not (self == other) + + def __hash__(self) -> int: + return hash((self.data, tuple(self.children))) + + def iter_subtrees(self) -> 'Iterator[Tree[_Leaf_T]]': + #-- + queue = [self] + subtrees = dict() + for subtree in queue: + subtrees[id(subtree)] = subtree + queue += [c for c in reversed(subtree.children) + if isinstance(c, Tree) and id(c) not in subtrees] + + del queue + return reversed(list(subtrees.values())) + + def iter_subtrees_topdown(self): + #-- + stack = [self] + stack_append = stack.append + stack_pop = stack.pop + while stack: + node = stack_pop() + if not isinstance(node, Tree): + continue + yield node + for child in reversed(node.children): + stack_append(child) + + def find_pred(self, pred: 'Callable[[Tree[_Leaf_T]], bool]') -> 'Iterator[Tree[_Leaf_T]]': + #-- + return filter(pred, self.iter_subtrees()) + + def find_data(self, data: str) -> 'Iterator[Tree[_Leaf_T]]': + #-- + return self.find_pred(lambda t: t.data == data) + + +from functools import wraps, update_wrapper +from inspect import getmembers, getmro + +_Return_T = TypeVar('_Return_T') +_Return_V = TypeVar('_Return_V') +_Leaf_T = TypeVar('_Leaf_T') +_Leaf_U = TypeVar('_Leaf_U') +_R = TypeVar('_R') +_FUNC = Callable[..., _Return_T] +_DECORATED = Union[_FUNC, type] + +class _DiscardType: + #-- + + def __repr__(self): + return "lark.visitors.Discard" + +Discard = _DiscardType() + +## + + +class _Decoratable: + #-- + + @classmethod + def _apply_v_args(cls, visit_wrapper): + mro = getmro(cls) + assert mro[0] is cls + libmembers = {name for _cls in mro[1:] for name, _ in getmembers(_cls)} + for name, value in getmembers(cls): + + ## + + if name.startswith('_') or (name in libmembers and name not in cls.__dict__): + continue + if not callable(value): + continue + + ## + + if isinstance(cls.__dict__[name], _VArgsWrapper): + continue + + setattr(cls, name, _VArgsWrapper(cls.__dict__[name], visit_wrapper)) + return cls + + def __class_getitem__(cls, _): + return cls + + +class Transformer(_Decoratable, ABC, Generic[_Leaf_T, _Return_T]): + #-- + __visit_tokens__ = True ## + + + def __init__(self, visit_tokens: bool=True) -> None: + self.__visit_tokens__ = visit_tokens + + def _call_userfunc(self, tree, new_children=None): + ## + + children = new_children if new_children is not None else tree.children + try: + f = getattr(self, tree.data) + except AttributeError: + return self.__default__(tree.data, children, tree.meta) + else: + try: + wrapper = getattr(f, 'visit_wrapper', None) + if wrapper is not None: + return f.visit_wrapper(f, tree.data, children, tree.meta) + else: + return f(children) + except GrammarError: + raise + except Exception as e: + raise VisitError(tree.data, tree, e) + + def _call_userfunc_token(self, token): + try: + f = getattr(self, token.type) + except AttributeError: + return self.__default_token__(token) + else: + try: + return f(token) + except GrammarError: + raise + except Exception as e: + raise VisitError(token.type, token, e) + + def _transform_children(self, children): + for c in children: + if isinstance(c, Tree): + res = self._transform_tree(c) + elif self.__visit_tokens__ and isinstance(c, Token): + res = self._call_userfunc_token(c) + else: + res = c + + if res is not Discard: + yield res + + def _transform_tree(self, tree): + children = list(self._transform_children(tree.children)) + return self._call_userfunc(tree, children) + + def transform(self, tree: Tree[_Leaf_T]) -> _Return_T: + #-- + res = list(self._transform_children([tree])) + if not res: + return None ## + + assert len(res) == 1 + return res[0] + + def __mul__( + self: 'Transformer[_Leaf_T, Tree[_Leaf_U]]', + other: 'Union[Transformer[_Leaf_U, _Return_V], TransformerChain[_Leaf_U, _Return_V,]]' + ) -> 'TransformerChain[_Leaf_T, _Return_V]': + #-- + return TransformerChain(self, other) + + def __default__(self, data, children, meta): + #-- + return Tree(data, children, meta) + + def __default_token__(self, token): + #-- + return token + + +def merge_transformers(base_transformer=None, **transformers_to_merge): + #-- + if base_transformer is None: + base_transformer = Transformer() + for prefix, transformer in transformers_to_merge.items(): + for method_name in dir(transformer): + method = getattr(transformer, method_name) + if not callable(method): + continue + if method_name.startswith("_") or method_name == "transform": + continue + prefixed_method = prefix + "__" + method_name + if hasattr(base_transformer, prefixed_method): + raise AttributeError("Cannot merge: method '%s' appears more than once" % prefixed_method) + + setattr(base_transformer, prefixed_method, method) + + return base_transformer + + +class InlineTransformer(Transformer): ## + + def _call_userfunc(self, tree, new_children=None): + ## + + children = new_children if new_children is not None else tree.children + try: + f = getattr(self, tree.data) + except AttributeError: + return self.__default__(tree.data, children, tree.meta) + else: + return f(*children) + + +class TransformerChain(Generic[_Leaf_T, _Return_T]): + + transformers: 'Tuple[Union[Transformer, TransformerChain], ...]' + + def __init__(self, *transformers: 'Union[Transformer, TransformerChain]') -> None: + self.transformers = transformers + + def transform(self, tree: Tree[_Leaf_T]) -> _Return_T: + for t in self.transformers: + tree = t.transform(tree) + return cast(_Return_T, tree) + + def __mul__( + self: 'TransformerChain[_Leaf_T, Tree[_Leaf_U]]', + other: 'Union[Transformer[_Leaf_U, _Return_V], TransformerChain[_Leaf_U, _Return_V]]' + ) -> 'TransformerChain[_Leaf_T, _Return_V]': + return TransformerChain(*self.transformers + (other,)) + + +class Transformer_InPlace(Transformer[_Leaf_T, _Return_T]): + #-- + def _transform_tree(self, tree): ## + + return self._call_userfunc(tree) + + def transform(self, tree: Tree[_Leaf_T]) -> _Return_T: + for subtree in tree.iter_subtrees(): + subtree.children = list(self._transform_children(subtree.children)) + + return self._transform_tree(tree) + + +class Transformer_NonRecursive(Transformer[_Leaf_T, _Return_T]): + #-- + + def transform(self, tree: Tree[_Leaf_T]) -> _Return_T: + ## + + rev_postfix = [] + q: List[Branch[_Leaf_T]] = [tree] + while q: + t = q.pop() + rev_postfix.append(t) + if isinstance(t, Tree): + q += t.children + + ## + + stack: List = [] + for x in reversed(rev_postfix): + if isinstance(x, Tree): + size = len(x.children) + if size: + args = stack[-size:] + del stack[-size:] + else: + args = [] + + res = self._call_userfunc(x, args) + if res is not Discard: + stack.append(res) + + elif self.__visit_tokens__ and isinstance(x, Token): + res = self._call_userfunc_token(x) + if res is not Discard: + stack.append(res) + else: + stack.append(x) + + result, = stack ## + + ## + + ## + + ## + + return cast(_Return_T, result) + + +class Transformer_InPlaceRecursive(Transformer[_Leaf_T, _Return_T]): + #-- + def _transform_tree(self, tree): + tree.children = list(self._transform_children(tree.children)) + return self._call_userfunc(tree) + + +## + + +class VisitorBase: + def _call_userfunc(self, tree): + return getattr(self, tree.data, self.__default__)(tree) + + def __default__(self, tree): + #-- + return tree + + def __class_getitem__(cls, _): + return cls + + +class Visitor(VisitorBase, ABC, Generic[_Leaf_T]): + #-- + + def visit(self, tree: Tree[_Leaf_T]) -> Tree[_Leaf_T]: + #-- + for subtree in tree.iter_subtrees(): + self._call_userfunc(subtree) + return tree + + def visit_topdown(self, tree: Tree[_Leaf_T]) -> Tree[_Leaf_T]: + #-- + for subtree in tree.iter_subtrees_topdown(): + self._call_userfunc(subtree) + return tree + + +class Visitor_Recursive(VisitorBase, Generic[_Leaf_T]): + #-- + + def visit(self, tree: Tree[_Leaf_T]) -> Tree[_Leaf_T]: + #-- + for child in tree.children: + if isinstance(child, Tree): + self.visit(child) + + self._call_userfunc(tree) + return tree + + def visit_topdown(self,tree: Tree[_Leaf_T]) -> Tree[_Leaf_T]: + #-- + self._call_userfunc(tree) + + for child in tree.children: + if isinstance(child, Tree): + self.visit_topdown(child) + + return tree + + +class Interpreter(_Decoratable, ABC, Generic[_Leaf_T, _Return_T]): + #-- + + def visit(self, tree: Tree[_Leaf_T]) -> _Return_T: + ## + + ## + + ## + + return self._visit_tree(tree) + + def _visit_tree(self, tree: Tree[_Leaf_T]): + f = getattr(self, tree.data) + wrapper = getattr(f, 'visit_wrapper', None) + if wrapper is not None: + return f.visit_wrapper(f, tree.data, tree.children, tree.meta) + else: + return f(tree) + + def visit_children(self, tree: Tree[_Leaf_T]) -> List: + return [self._visit_tree(child) if isinstance(child, Tree) else child + for child in tree.children] + + def __getattr__(self, name): + return self.__default__ + + def __default__(self, tree): + return self.visit_children(tree) + + +_InterMethod = Callable[[Type[Interpreter], _Return_T], _R] + +def visit_children_decor(func: _InterMethod) -> _InterMethod: + #-- + @wraps(func) + def inner(cls, tree): + values = cls.visit_children(tree) + return func(cls, values) + return inner + +## + + +def _apply_v_args(obj, visit_wrapper): + try: + _apply = obj._apply_v_args + except AttributeError: + return _VArgsWrapper(obj, visit_wrapper) + else: + return _apply(visit_wrapper) + + +class _VArgsWrapper: + #-- + base_func: Callable + + def __init__(self, func: Callable, visit_wrapper: Callable[[Callable, str, list, Any], Any]): + if isinstance(func, _VArgsWrapper): + func = func.base_func + self.base_func = func + self.visit_wrapper = visit_wrapper + update_wrapper(self, func) + + def __call__(self, *args, **kwargs): + return self.base_func(*args, **kwargs) + + def __get__(self, instance, owner=None): + try: + ## + + ## + + g = type(self.base_func).__get__ + except AttributeError: + return self + else: + return _VArgsWrapper(g(self.base_func, instance, owner), self.visit_wrapper) + + def __set_name__(self, owner, name): + try: + f = type(self.base_func).__set_name__ + except AttributeError: + return + else: + f(self.base_func, owner, name) + + +def _vargs_inline(f, _data, children, _meta): + return f(*children) +def _vargs_meta_inline(f, _data, children, meta): + return f(meta, *children) +def _vargs_meta(f, _data, children, meta): + return f(meta, children) +def _vargs_tree(f, data, children, meta): + return f(Tree(data, children, meta)) + + +def v_args(inline: bool = False, meta: bool = False, tree: bool = False, wrapper: Optional[Callable] = None) -> Callable[[_DECORATED], _DECORATED]: + #-- + if tree and (meta or inline): + raise ValueError("Visitor functions cannot combine 'tree' with 'meta' or 'inline'.") + + func = None + if meta: + if inline: + func = _vargs_meta_inline + else: + func = _vargs_meta + elif inline: + func = _vargs_inline + elif tree: + func = _vargs_tree + + if wrapper is not None: + if func is not None: + raise ValueError("Cannot use 'wrapper' along with 'tree', 'meta' or 'inline'.") + func = wrapper + + def _visitor_args_dec(obj): + return _apply_v_args(obj, func) + return _visitor_args_dec + + + +TOKEN_DEFAULT_PRIORITY = 0 + + +class Symbol(Serialize): + __slots__ = ('name',) + + name: str + is_term: ClassVar[bool] = NotImplemented + + def __init__(self, name: str) -> None: + self.name = name + + def __eq__(self, other): + if not isinstance(other, Symbol): + return NotImplemented + return self.is_term == other.is_term and self.name == other.name + + def __ne__(self, other): + return not (self == other) + + def __hash__(self): + return hash(self.name) + + def __repr__(self): + return '%s(%r)' % (type(self).__name__, self.name) + + fullrepr = property(__repr__) + + def renamed(self, f): + return type(self)(f(self.name)) + + +class Terminal(Symbol): + __serialize_fields__ = 'name', 'filter_out' + + is_term: ClassVar[bool] = True + + def __init__(self, name: str, filter_out: bool = False) -> None: + self.name = name + self.filter_out = filter_out + + @property + def fullrepr(self): + return '%s(%r, %r)' % (type(self).__name__, self.name, self.filter_out) + + def renamed(self, f): + return type(self)(f(self.name), self.filter_out) + + +class NonTerminal(Symbol): + __serialize_fields__ = 'name', + + is_term: ClassVar[bool] = False + + def serialize(self, memo=None) -> Dict[str, Any]: + ## + + ## + + return {'name': str(self.name), '__type__': 'NonTerminal'} + + +class RuleOptions(Serialize): + __serialize_fields__ = 'keep_all_tokens', 'expand1', 'priority', 'template_source', 'empty_indices' + + keep_all_tokens: bool + expand1: bool + priority: Optional[int] + template_source: Optional[str] + empty_indices: Tuple[bool, ...] + + def __init__(self, keep_all_tokens: bool=False, expand1: bool=False, priority: Optional[int]=None, template_source: Optional[str]=None, empty_indices: Tuple[bool, ...]=()) -> None: + self.keep_all_tokens = keep_all_tokens + self.expand1 = expand1 + self.priority = priority + self.template_source = template_source + self.empty_indices = empty_indices + + def __repr__(self): + return 'RuleOptions(%r, %r, %r, %r)' % ( + self.keep_all_tokens, + self.expand1, + self.priority, + self.template_source + ) + + +class Rule(Serialize): + #-- + __slots__ = ('origin', 'expansion', 'alias', 'options', 'order', '_hash') + + __serialize_fields__ = 'origin', 'expansion', 'order', 'alias', 'options' + __serialize_namespace__ = Terminal, NonTerminal, RuleOptions + + origin: NonTerminal + expansion: Sequence[Symbol] + order: int + alias: Optional[str] + options: RuleOptions + _hash: int + + def __init__(self, origin: NonTerminal, expansion: Sequence[Symbol], + order: int=0, alias: Optional[str]=None, options: Optional[RuleOptions]=None): + self.origin = origin + self.expansion = expansion + self.alias = alias + self.order = order + self.options = options or RuleOptions() + self._hash = hash((self.origin, tuple(self.expansion))) + + def _deserialize(self): + self._hash = hash((self.origin, tuple(self.expansion))) + + def __str__(self): + return '<%s : %s>' % (self.origin.name, ' '.join(x.name for x in self.expansion)) + + def __repr__(self): + return 'Rule(%r, %r, %r, %r)' % (self.origin, self.expansion, self.alias, self.options) + + def __hash__(self): + return self._hash + + def __eq__(self, other): + if not isinstance(other, Rule): + return False + return self.origin == other.origin and self.expansion == other.expansion + + + +from contextlib import suppress +from copy import copy + +try: ## + + has_interegular = bool(interegular) +except NameError: + has_interegular = False + +class Pattern(Serialize, ABC): + #-- + + value: str + flags: Collection[str] + raw: Optional[str] + type: ClassVar[str] + + def __init__(self, value: str, flags: Collection[str] = (), raw: Optional[str] = None) -> None: + self.value = value + self.flags = frozenset(flags) + self.raw = raw + + def __repr__(self): + return repr(self.to_regexp()) + + ## + + def __hash__(self): + return hash((type(self), self.value, self.flags)) + + def __eq__(self, other): + return type(self) == type(other) and self.value == other.value and self.flags == other.flags + + @abstractmethod + def to_regexp(self) -> str: + raise NotImplementedError() + + @property + @abstractmethod + def min_width(self) -> int: + raise NotImplementedError() + + @property + @abstractmethod + def max_width(self) -> int: + raise NotImplementedError() + + def _get_flags(self, value): + for f in self.flags: + value = ('(?%s:%s)' % (f, value)) + return value + + +class PatternStr(Pattern): + __serialize_fields__ = 'value', 'flags', 'raw' + + type: ClassVar[str] = "str" + + def to_regexp(self) -> str: + return self._get_flags(re.escape(self.value)) + + @property + def min_width(self) -> int: + return len(self.value) + + @property + def max_width(self) -> int: + return len(self.value) + + +class PatternRE(Pattern): + __serialize_fields__ = 'value', 'flags', 'raw', '_width' + + type: ClassVar[str] = "re" + + def to_regexp(self) -> str: + return self._get_flags(self.value) + + _width = None + def _get_width(self): + if self._width is None: + self._width = get_regexp_width(self.to_regexp()) + return self._width + + @property + def min_width(self) -> int: + return self._get_width()[0] + + @property + def max_width(self) -> int: + return self._get_width()[1] + + +class TerminalDef(Serialize): + #-- + __serialize_fields__ = 'name', 'pattern', 'priority' + __serialize_namespace__ = PatternStr, PatternRE + + name: str + pattern: Pattern + priority: int + + def __init__(self, name: str, pattern: Pattern, priority: int = TOKEN_DEFAULT_PRIORITY) -> None: + assert isinstance(pattern, Pattern), pattern + self.name = name + self.pattern = pattern + self.priority = priority + + def __repr__(self): + return '%s(%r, %r)' % (type(self).__name__, self.name, self.pattern) + + def user_repr(self) -> str: + if self.name.startswith('__'): ## + + return self.pattern.raw or self.name + else: + return self.name + +_T = TypeVar('_T', bound="Token") + +class Token(str): + #-- + __slots__ = ('type', 'start_pos', 'value', 'line', 'column', 'end_line', 'end_column', 'end_pos') + + __match_args__ = ('type', 'value') + + type: str + start_pos: Optional[int] + value: Any + line: Optional[int] + column: Optional[int] + end_line: Optional[int] + end_column: Optional[int] + end_pos: Optional[int] + + + @overload + def __new__( + cls, + type: str, + value: Any, + start_pos: Optional[int] = None, + line: Optional[int] = None, + column: Optional[int] = None, + end_line: Optional[int] = None, + end_column: Optional[int] = None, + end_pos: Optional[int] = None + ) -> 'Token': + ... + + @overload + def __new__( + cls, + type_: str, + value: Any, + start_pos: Optional[int] = None, + line: Optional[int] = None, + column: Optional[int] = None, + end_line: Optional[int] = None, + end_column: Optional[int] = None, + end_pos: Optional[int] = None + ) -> 'Token': ... + + def __new__(cls, *args, **kwargs): + if "type_" in kwargs: + warnings.warn("`type_` is deprecated use `type` instead", DeprecationWarning) + + if "type" in kwargs: + raise TypeError("Error: using both 'type' and the deprecated 'type_' as arguments.") + kwargs["type"] = kwargs.pop("type_") + + return cls._future_new(*args, **kwargs) + + + @classmethod + def _future_new(cls, type, value, start_pos=None, line=None, column=None, end_line=None, end_column=None, end_pos=None): + inst = super(Token, cls).__new__(cls, value) + + inst.type = type + inst.start_pos = start_pos + inst.value = value + inst.line = line + inst.column = column + inst.end_line = end_line + inst.end_column = end_column + inst.end_pos = end_pos + return inst + + @overload + def update(self, type: Optional[str] = None, value: Optional[Any] = None) -> 'Token': + ... + + @overload + def update(self, type_: Optional[str] = None, value: Optional[Any] = None) -> 'Token': + ... + + def update(self, *args, **kwargs): + if "type_" in kwargs: + warnings.warn("`type_` is deprecated use `type` instead", DeprecationWarning) + + if "type" in kwargs: + raise TypeError("Error: using both 'type' and the deprecated 'type_' as arguments.") + kwargs["type"] = kwargs.pop("type_") + + return self._future_update(*args, **kwargs) + + def _future_update(self, type: Optional[str] = None, value: Optional[Any] = None) -> 'Token': + return Token.new_borrow_pos( + type if type is not None else self.type, + value if value is not None else self.value, + self + ) + + @classmethod + def new_borrow_pos(cls: Type[_T], type_: str, value: Any, borrow_t: 'Token') -> _T: + return cls(type_, value, borrow_t.start_pos, borrow_t.line, borrow_t.column, borrow_t.end_line, borrow_t.end_column, borrow_t.end_pos) + + def __reduce__(self): + return (self.__class__, (self.type, self.value, self.start_pos, self.line, self.column)) + + def __repr__(self): + return 'Token(%r, %r)' % (self.type, self.value) + + def __deepcopy__(self, memo): + return Token(self.type, self.value, self.start_pos, self.line, self.column) + + def __eq__(self, other): + if isinstance(other, Token) and self.type != other.type: + return False + + return str.__eq__(self, other) + + __hash__ = str.__hash__ + + +class LineCounter: + #-- + + __slots__ = 'char_pos', 'line', 'column', 'line_start_pos', 'newline_char' + + def __init__(self, newline_char): + self.newline_char = newline_char + self.char_pos = 0 + self.line = 1 + self.column = 1 + self.line_start_pos = 0 + + def __eq__(self, other): + if not isinstance(other, LineCounter): + return NotImplemented + + return self.char_pos == other.char_pos and self.newline_char == other.newline_char + + def feed(self, token: TextOrSlice, test_newline=True): + #-- + if test_newline: + newlines = token.count(self.newline_char) + if newlines: + self.line += newlines + self.line_start_pos = self.char_pos + token.rindex(self.newline_char) + 1 + + self.char_pos += len(token) + self.column = self.char_pos - self.line_start_pos + 1 + + +class UnlessCallback: + def __init__(self, scanner: 'Scanner'): + self.scanner = scanner + + def __call__(self, t: Token): + res = self.scanner.fullmatch(t.value) + if res is not None: + t.type = res + return t + + +class CallChain: + def __init__(self, callback1, callback2, cond): + self.callback1 = callback1 + self.callback2 = callback2 + self.cond = cond + + def __call__(self, t): + t2 = self.callback1(t) + return self.callback2(t) if self.cond(t2) else t2 + + +def _get_match(re_, regexp, s, flags): + m = re_.match(regexp, s, flags) + if m: + return m.group(0) + +def _create_unless(terminals, g_regex_flags, re_, use_bytes): + tokens_by_type = classify(terminals, lambda t: type(t.pattern)) + assert len(tokens_by_type) <= 2, tokens_by_type.keys() + embedded_strs = set() + callback = {} + for retok in tokens_by_type.get(PatternRE, []): + unless = [] + for strtok in tokens_by_type.get(PatternStr, []): + if strtok.priority != retok.priority: + continue + s = strtok.pattern.value + if s == _get_match(re_, retok.pattern.to_regexp(), s, g_regex_flags): + unless.append(strtok) + if strtok.pattern.flags <= retok.pattern.flags: + embedded_strs.add(strtok) + if unless: + callback[retok.name] = UnlessCallback(Scanner(unless, g_regex_flags, re_, use_bytes=use_bytes)) + + new_terminals = [t for t in terminals if t not in embedded_strs] + return new_terminals, callback + + +class Scanner: + def __init__(self, terminals, g_regex_flags, re_, use_bytes): + self.terminals = terminals + self.g_regex_flags = g_regex_flags + self.re_ = re_ + self.use_bytes = use_bytes + + self.allowed_types = {t.name for t in self.terminals} + + self._mres = self._build_mres(terminals, len(terminals)) + + def _build_mres(self, terminals, max_size): + ## + + ## + + ## + + mres = [] + while terminals: + pattern = u'|'.join(u'(?P<%s>%s)' % (t.name, t.pattern.to_regexp()) for t in terminals[:max_size]) + if self.use_bytes: + pattern = pattern.encode('latin-1') + try: + mre = self.re_.compile(pattern, self.g_regex_flags) + except AssertionError: ## + + return self._build_mres(terminals, max_size // 2) + + mres.append(mre) + terminals = terminals[max_size:] + return mres + + def match(self, text: TextSlice, pos): + for mre in self._mres: + m = mre.match(text.text, pos, text.end) + if m: + return m.group(0), m.lastgroup + + + def fullmatch(self, text: str) -> Optional[str]: + for mre in self._mres: + m = mre.fullmatch(text) + if m: + return m.lastgroup + return None + +def _regexp_has_newline(r: str): + #-- + return '\n' in r or '\\n' in r or '\\s' in r or '[^' in r or ('(?s' in r and '.' in r) + + +class LexerState: + #-- + + __slots__ = 'text', 'line_ctr', 'last_token' + + text: TextSlice + line_ctr: LineCounter + last_token: Optional[Token] + + def __init__(self, text: TextSlice, line_ctr: Optional[LineCounter] = None, last_token: Optional[Token]=None): + if isinstance(text, TextSlice): + if line_ctr is None: + line_ctr = LineCounter(b'\n' if isinstance(text.text, bytes) else '\n') + + if text.start > 0: + ## + + line_ctr.feed(TextSlice(text.text, 0, text.start)) + + if not (text.start <= line_ctr.char_pos <= text.end): + raise ValueError("LineCounter.char_pos is out of bounds") + + self.text = text + self.line_ctr = line_ctr + self.last_token = last_token + + + def __eq__(self, other): + if not isinstance(other, LexerState): + return NotImplemented + + return self.text == other.text and self.line_ctr == other.line_ctr and self.last_token == other.last_token + + def __copy__(self): + return type(self)(self.text, copy(self.line_ctr), self.last_token) + + +class LexerThread: + #-- + + def __init__(self, lexer: 'Lexer', lexer_state: Optional[LexerState]): + self.lexer = lexer + self.state = lexer_state + + @classmethod + def from_text(cls, lexer: 'Lexer', text_or_slice: TextOrSlice) -> 'LexerThread': + text = TextSlice.cast_from(text_or_slice) + return cls(lexer, LexerState(text)) + + @classmethod + def from_custom_input(cls, lexer: 'Lexer', text: Any) -> 'LexerThread': + return cls(lexer, LexerState(text)) + + def lex(self, parser_state): + if self.state is None: + raise TypeError("Cannot lex: No text assigned to lexer state") + return self.lexer.lex(self.state, parser_state) + + def __copy__(self): + return type(self)(self.lexer, copy(self.state)) + + _Token = Token + + +_Callback = Callable[[Token], Token] + +class Lexer(ABC): + #-- + @abstractmethod + def lex(self, lexer_state: LexerState, parser_state: Any) -> Iterator[Token]: + return NotImplemented + + def make_lexer_state(self, text: str): + #-- + return LexerState(TextSlice.cast_from(text)) + + +def _check_regex_collisions(terminal_to_regexp: Dict[TerminalDef, str], comparator, strict_mode, max_collisions_to_show=8): + if not comparator: + comparator = interegular.Comparator.from_regexes(terminal_to_regexp) + + ## + + ## + + max_time = 2 if strict_mode else 0.2 + + ## + + if comparator.count_marked_pairs() >= max_collisions_to_show: + return + for group in classify(terminal_to_regexp, lambda t: t.priority).values(): + for a, b in comparator.check(group, skip_marked=True): + assert a.priority == b.priority + ## + + comparator.mark(a, b) + + ## + + message = f"Collision between Terminals {a.name} and {b.name}. " + try: + example = comparator.get_example_overlap(a, b, max_time).format_multiline() + except ValueError: + ## + + example = "No example could be found fast enough. However, the collision does still exists" + if strict_mode: + raise LexError(f"{message}\n{example}") + logger.warning("%s The lexer will choose between them arbitrarily.\n%s", message, example) + if comparator.count_marked_pairs() >= max_collisions_to_show: + logger.warning("Found 8 regex collisions, will not check for more.") + return + + +class AbstractBasicLexer(Lexer): + terminals_by_name: Dict[str, TerminalDef] + + @abstractmethod + def __init__(self, conf: 'LexerConf', comparator=None) -> None: + ... + + @abstractmethod + def next_token(self, lex_state: LexerState, parser_state: Any = None) -> Token: + ... + + def lex(self, state: LexerState, parser_state: Any) -> Iterator[Token]: + with suppress(EOFError): + while True: + yield self.next_token(state, parser_state) + + +class BasicLexer(AbstractBasicLexer): + terminals: Collection[TerminalDef] + ignore_types: FrozenSet[str] + newline_types: FrozenSet[str] + user_callbacks: Dict[str, _Callback] + callback: Dict[str, _Callback] + re: ModuleType + + def __init__(self, conf: 'LexerConf', comparator=None) -> None: + terminals = list(conf.terminals) + assert all(isinstance(t, TerminalDef) for t in terminals), terminals + + self.re = conf.re_module + + if not conf.skip_validation: + ## + + terminal_to_regexp = {} + for t in terminals: + regexp = t.pattern.to_regexp() + try: + self.re.compile(regexp, conf.g_regex_flags) + except self.re.error: + raise LexError("Cannot compile token %s: %s" % (t.name, t.pattern)) + + if t.pattern.min_width == 0: + raise LexError("Lexer does not allow zero-width terminals. (%s: %s)" % (t.name, t.pattern)) + if t.pattern.type == "re": + terminal_to_regexp[t] = regexp + + if not (set(conf.ignore) <= {t.name for t in terminals}): + raise LexError("Ignore terminals are not defined: %s" % (set(conf.ignore) - {t.name for t in terminals})) + + if has_interegular: + _check_regex_collisions(terminal_to_regexp, comparator, conf.strict) + elif conf.strict: + raise LexError("interegular must be installed for strict mode. Use `pip install 'lark[interegular]'`.") + + ## + + self.newline_types = frozenset(t.name for t in terminals if _regexp_has_newline(t.pattern.to_regexp())) + self.ignore_types = frozenset(conf.ignore) + + terminals.sort(key=lambda x: (-x.priority, -x.pattern.max_width, -len(x.pattern.value), x.name)) + self.terminals = terminals + self.user_callbacks = conf.callbacks + self.g_regex_flags = conf.g_regex_flags + self.use_bytes = conf.use_bytes + self.terminals_by_name = conf.terminals_by_name + + self._scanner: Optional[Scanner] = None + + def _build_scanner(self) -> Scanner: + terminals, self.callback = _create_unless(self.terminals, self.g_regex_flags, self.re, self.use_bytes) + assert all(self.callback.values()) + + for type_, f in self.user_callbacks.items(): + if type_ in self.callback: + ## + + self.callback[type_] = CallChain(self.callback[type_], f, lambda t: t.type == type_) + else: + self.callback[type_] = f + + return Scanner(terminals, self.g_regex_flags, self.re, self.use_bytes) + + @property + def scanner(self) -> Scanner: + if self._scanner is None: + self._scanner = self._build_scanner() + return self._scanner + + def match(self, text, pos): + return self.scanner.match(text, pos) + + def next_token(self, lex_state: LexerState, parser_state: Any = None) -> Token: + line_ctr = lex_state.line_ctr + while line_ctr.char_pos < lex_state.text.end: + res = self.match(lex_state.text, line_ctr.char_pos) + if not res: + allowed = self.scanner.allowed_types - self.ignore_types + if not allowed: + allowed = {""} + raise UnexpectedCharacters(lex_state.text.text, line_ctr.char_pos, line_ctr.line, line_ctr.column, + allowed=allowed, token_history=lex_state.last_token and [lex_state.last_token], + state=parser_state, terminals_by_name=self.terminals_by_name) + + value, type_ = res + + ignored = type_ in self.ignore_types + t = None + if not ignored or type_ in self.callback: + t = Token(type_, value, line_ctr.char_pos, line_ctr.line, line_ctr.column) + line_ctr.feed(value, type_ in self.newline_types) + if t is not None: + t.end_line = line_ctr.line + t.end_column = line_ctr.column + t.end_pos = line_ctr.char_pos + if t.type in self.callback: + t = self.callback[t.type](t) + if not ignored: + if not isinstance(t, Token): + raise LexError("Callbacks must return a token (returned %r)" % t) + lex_state.last_token = t + return t + + ## + + raise EOFError(self) + + +class ContextualLexer(Lexer): + lexers: Dict[int, AbstractBasicLexer] + root_lexer: AbstractBasicLexer + + BasicLexer: Type[AbstractBasicLexer] = BasicLexer + + def __init__(self, conf: 'LexerConf', states: Dict[int, Collection[str]], always_accept: Collection[str]=()) -> None: + terminals = list(conf.terminals) + terminals_by_name = conf.terminals_by_name + + trad_conf = copy(conf) + trad_conf.terminals = terminals + + if has_interegular and not conf.skip_validation: + comparator = interegular.Comparator.from_regexes({t: t.pattern.to_regexp() for t in terminals}) + else: + comparator = None + lexer_by_tokens: Dict[FrozenSet[str], AbstractBasicLexer] = {} + self.lexers = {} + for state, accepts in states.items(): + key = frozenset(accepts) + try: + lexer = lexer_by_tokens[key] + except KeyError: + accepts = set(accepts) | set(conf.ignore) | set(always_accept) + lexer_conf = copy(trad_conf) + lexer_conf.terminals = [terminals_by_name[n] for n in accepts if n in terminals_by_name] + lexer = self.BasicLexer(lexer_conf, comparator) + lexer_by_tokens[key] = lexer + + self.lexers[state] = lexer + + assert trad_conf.terminals is terminals + trad_conf.skip_validation = True ## + + self.root_lexer = self.BasicLexer(trad_conf, comparator) + + def lex(self, lexer_state: LexerState, parser_state: 'ParserState') -> Iterator[Token]: + try: + while True: + lexer = self.lexers[parser_state.position] + yield lexer.next_token(lexer_state, parser_state) + except EOFError: + pass + except UnexpectedCharacters as e: + ## + + ## + + try: + last_token = lexer_state.last_token ## + + token = self.root_lexer.next_token(lexer_state, parser_state) + raise UnexpectedToken(token, e.allowed, state=parser_state, token_history=[last_token], terminals_by_name=self.root_lexer.terminals_by_name) + except UnexpectedCharacters: + raise e ## + + + + +_ParserArgType: 'TypeAlias' = 'Literal["earley", "lalr", "cyk", "auto"]' +_LexerArgType: 'TypeAlias' = 'Union[Literal["auto", "basic", "contextual", "dynamic", "dynamic_complete"], Type[Lexer]]' +_LexerCallback = Callable[[Token], Token] +ParserCallbacks = Dict[str, Callable] + +class LexerConf(Serialize): + __serialize_fields__ = 'terminals', 'ignore', 'g_regex_flags', 'use_bytes', 'lexer_type' + __serialize_namespace__ = TerminalDef, + + terminals: Collection[TerminalDef] + re_module: ModuleType + ignore: Collection[str] + postlex: 'Optional[PostLex]' + callbacks: Dict[str, _LexerCallback] + g_regex_flags: int + skip_validation: bool + use_bytes: bool + lexer_type: Optional[_LexerArgType] + strict: bool + + def __init__(self, terminals: Collection[TerminalDef], re_module: ModuleType, ignore: Collection[str]=(), postlex: 'Optional[PostLex]'=None, + callbacks: Optional[Dict[str, _LexerCallback]]=None, g_regex_flags: int=0, skip_validation: bool=False, use_bytes: bool=False, strict: bool=False): + self.terminals = terminals + self.terminals_by_name = {t.name: t for t in self.terminals} + assert len(self.terminals) == len(self.terminals_by_name) + self.ignore = ignore + self.postlex = postlex + self.callbacks = callbacks or {} + self.g_regex_flags = g_regex_flags + self.re_module = re_module + self.skip_validation = skip_validation + self.use_bytes = use_bytes + self.strict = strict + self.lexer_type = None + + def _deserialize(self): + self.terminals_by_name = {t.name: t for t in self.terminals} + + def __deepcopy__(self, memo=None): + return type(self)( + deepcopy(self.terminals, memo), + self.re_module, + deepcopy(self.ignore, memo), + deepcopy(self.postlex, memo), + deepcopy(self.callbacks, memo), + deepcopy(self.g_regex_flags, memo), + deepcopy(self.skip_validation, memo), + deepcopy(self.use_bytes, memo), + ) + +class ParserConf(Serialize): + __serialize_fields__ = 'rules', 'start', 'parser_type' + + rules: List['Rule'] + callbacks: ParserCallbacks + start: List[str] + parser_type: _ParserArgType + + def __init__(self, rules: List['Rule'], callbacks: ParserCallbacks, start: List[str]): + assert isinstance(start, list) + self.rules = rules + self.callbacks = callbacks + self.start = start + + +from functools import partial, wraps +from itertools import product + + +class ExpandSingleChild: + def __init__(self, node_builder): + self.node_builder = node_builder + + def __call__(self, children): + if len(children) == 1: + return children[0] + else: + return self.node_builder(children) + + + +class PropagatePositions: + def __init__(self, node_builder, node_filter=None): + self.node_builder = node_builder + self.node_filter = node_filter + + def __call__(self, children): + res = self.node_builder(children) + + if isinstance(res, Tree): + ## + + ## + + ## + + ## + + + res_meta = res.meta + + first_meta = self._pp_get_meta(children) + if first_meta is not None: + if not hasattr(res_meta, 'line'): + ## + + res_meta.line = getattr(first_meta, 'container_line', first_meta.line) + res_meta.column = getattr(first_meta, 'container_column', first_meta.column) + res_meta.start_pos = getattr(first_meta, 'container_start_pos', first_meta.start_pos) + res_meta.empty = False + + res_meta.container_line = getattr(first_meta, 'container_line', first_meta.line) + res_meta.container_column = getattr(first_meta, 'container_column', first_meta.column) + res_meta.container_start_pos = getattr(first_meta, 'container_start_pos', first_meta.start_pos) + + last_meta = self._pp_get_meta(reversed(children)) + if last_meta is not None: + if not hasattr(res_meta, 'end_line'): + res_meta.end_line = getattr(last_meta, 'container_end_line', last_meta.end_line) + res_meta.end_column = getattr(last_meta, 'container_end_column', last_meta.end_column) + res_meta.end_pos = getattr(last_meta, 'container_end_pos', last_meta.end_pos) + res_meta.empty = False + + res_meta.container_end_line = getattr(last_meta, 'container_end_line', last_meta.end_line) + res_meta.container_end_column = getattr(last_meta, 'container_end_column', last_meta.end_column) + res_meta.container_end_pos = getattr(last_meta, 'container_end_pos', last_meta.end_pos) + + return res + + def _pp_get_meta(self, children): + for c in children: + if self.node_filter is not None and not self.node_filter(c): + continue + if isinstance(c, Tree): + if not c.meta.empty: + return c.meta + elif isinstance(c, Token): + return c + elif hasattr(c, '__lark_meta__'): + return c.__lark_meta__() + +def make_propagate_positions(option): + if callable(option): + return partial(PropagatePositions, node_filter=option) + elif option is True: + return PropagatePositions + elif option is False: + return None + + raise ConfigurationError('Invalid option for propagate_positions: %r' % option) + + +class ChildFilter: + def __init__(self, to_include, append_none, node_builder): + self.node_builder = node_builder + self.to_include = to_include + self.append_none = append_none + + def __call__(self, children): + filtered = [] + + for i, to_expand, add_none in self.to_include: + if add_none: + filtered += [None] * add_none + if to_expand: + filtered += children[i].children + else: + filtered.append(children[i]) + + if self.append_none: + filtered += [None] * self.append_none + + return self.node_builder(filtered) + + +class ChildFilterLALR(ChildFilter): + #-- + + def __call__(self, children): + filtered = [] + for i, to_expand, add_none in self.to_include: + if add_none: + filtered += [None] * add_none + if to_expand: + if filtered: + filtered += children[i].children + else: ## + + filtered = children[i].children + else: + filtered.append(children[i]) + + if self.append_none: + filtered += [None] * self.append_none + + return self.node_builder(filtered) + + +class ChildFilterLALR_NoPlaceholders(ChildFilter): + #-- + def __init__(self, to_include, node_builder): + self.node_builder = node_builder + self.to_include = to_include + + def __call__(self, children): + filtered = [] + for i, to_expand in self.to_include: + if to_expand: + if filtered: + filtered += children[i].children + else: ## + + filtered = children[i].children + else: + filtered.append(children[i]) + return self.node_builder(filtered) + + +def _should_expand(sym): + return not sym.is_term and sym.name.startswith('_') + + +def maybe_create_child_filter(expansion, keep_all_tokens, ambiguous, _empty_indices: List[bool]): + ## + + if _empty_indices: + assert _empty_indices.count(False) == len(expansion) + s = ''.join(str(int(b)) for b in _empty_indices) + empty_indices = [len(ones) for ones in s.split('0')] + assert len(empty_indices) == len(expansion)+1, (empty_indices, len(expansion)) + else: + empty_indices = [0] * (len(expansion)+1) + + to_include = [] + nones_to_add = 0 + for i, sym in enumerate(expansion): + nones_to_add += empty_indices[i] + if keep_all_tokens or not (sym.is_term and sym.filter_out): + to_include.append((i, _should_expand(sym), nones_to_add)) + nones_to_add = 0 + + nones_to_add += empty_indices[len(expansion)] + + if _empty_indices or len(to_include) < len(expansion) or any(to_expand for i, to_expand,_ in to_include): + if _empty_indices or ambiguous: + return partial(ChildFilter if ambiguous else ChildFilterLALR, to_include, nones_to_add) + else: + ## + + return partial(ChildFilterLALR_NoPlaceholders, [(i, x) for i,x,_ in to_include]) + + +class AmbiguousExpander: + #-- + def __init__(self, to_expand, tree_class, node_builder): + self.node_builder = node_builder + self.tree_class = tree_class + self.to_expand = to_expand + + def __call__(self, children): + def _is_ambig_tree(t): + return hasattr(t, 'data') and t.data == '_ambig' + + ## + + ## + + ## + + ## + + ambiguous = [] + for i, child in enumerate(children): + if _is_ambig_tree(child): + if i in self.to_expand: + ambiguous.append(i) + + child.expand_kids_by_data('_ambig') + + if not ambiguous: + return self.node_builder(children) + + expand = [child.children if i in ambiguous else (child,) for i, child in enumerate(children)] + return self.tree_class('_ambig', [self.node_builder(list(f)) for f in product(*expand)]) + + +def maybe_create_ambiguous_expander(tree_class, expansion, keep_all_tokens): + to_expand = [i for i, sym in enumerate(expansion) + if keep_all_tokens or ((not (sym.is_term and sym.filter_out)) and _should_expand(sym))] + if to_expand: + return partial(AmbiguousExpander, to_expand, tree_class) + + +class AmbiguousIntermediateExpander: + #-- + + def __init__(self, tree_class, node_builder): + self.node_builder = node_builder + self.tree_class = tree_class + + def __call__(self, children): + def _is_iambig_tree(child): + return hasattr(child, 'data') and child.data == '_iambig' + + def _collapse_iambig(children): + #-- + + ## + + ## + + if children and _is_iambig_tree(children[0]): + iambig_node = children[0] + result = [] + for grandchild in iambig_node.children: + collapsed = _collapse_iambig(grandchild.children) + if collapsed: + for child in collapsed: + child.children += children[1:] + result += collapsed + else: + new_tree = self.tree_class('_inter', grandchild.children + children[1:]) + result.append(new_tree) + return result + + collapsed = _collapse_iambig(children) + if collapsed: + processed_nodes = [self.node_builder(c.children) for c in collapsed] + return self.tree_class('_ambig', processed_nodes) + + return self.node_builder(children) + + + +def inplace_transformer(func): + @wraps(func) + def f(children): + ## + + tree = Tree(func.__name__, children) + return func(tree) + return f + + +def apply_visit_wrapper(func, name, wrapper): + if wrapper is _vargs_meta or wrapper is _vargs_meta_inline: + raise NotImplementedError("Meta args not supported for internal transformer; use YourTransformer().transform(parser.parse()) instead") + + @wraps(func) + def f(children): + return wrapper(func, name, children, None) + return f + + +class ParseTreeBuilder: + def __init__(self, rules, tree_class, propagate_positions=False, ambiguous=False, maybe_placeholders=False): + self.tree_class = tree_class + self.propagate_positions = propagate_positions + self.ambiguous = ambiguous + self.maybe_placeholders = maybe_placeholders + + self.rule_builders = list(self._init_builders(rules)) + + def _init_builders(self, rules): + propagate_positions = make_propagate_positions(self.propagate_positions) + + for rule in rules: + options = rule.options + keep_all_tokens = options.keep_all_tokens + expand_single_child = options.expand1 + + wrapper_chain = list(filter(None, [ + (expand_single_child and not rule.alias) and ExpandSingleChild, + maybe_create_child_filter(rule.expansion, keep_all_tokens, self.ambiguous, options.empty_indices if self.maybe_placeholders else None), + propagate_positions, + self.ambiguous and maybe_create_ambiguous_expander(self.tree_class, rule.expansion, keep_all_tokens), + self.ambiguous and partial(AmbiguousIntermediateExpander, self.tree_class) + ])) + + yield rule, wrapper_chain + + def create_callback(self, transformer=None): + callbacks = {} + + default_handler = getattr(transformer, '__default__', None) + if default_handler: + def default_callback(data, children): + return default_handler(data, children, None) + else: + default_callback = self.tree_class + + for rule, wrapper_chain in self.rule_builders: + + user_callback_name = rule.alias or rule.options.template_source or rule.origin.name + try: + f = getattr(transformer, user_callback_name) + wrapper = getattr(f, 'visit_wrapper', None) + if wrapper is not None: + f = apply_visit_wrapper(f, user_callback_name, wrapper) + elif isinstance(transformer, Transformer_InPlace): + f = inplace_transformer(f) + except AttributeError: + f = partial(default_callback, user_callback_name) + + for w in wrapper_chain: + f = w(f) + + if rule in callbacks: + raise GrammarError("Rule '%s' already exists" % (rule,)) + + callbacks[rule] = f + + return callbacks + + + +class Action: + def __init__(self, name): + self.name = name + def __str__(self): + return self.name + def __repr__(self): + return str(self) + +Shift = Action('Shift') +Reduce = Action('Reduce') + +StateT = TypeVar("StateT") + +class ParseTableBase(Generic[StateT]): + states: Dict[StateT, Dict[str, Tuple]] + start_states: Dict[str, StateT] + end_states: Dict[str, StateT] + + def __init__(self, states, start_states, end_states): + self.states = states + self.start_states = start_states + self.end_states = end_states + + def serialize(self, memo): + tokens = Enumerator() + + states = { + state: {tokens.get(token): ((1, arg.serialize(memo)) if action is Reduce else (0, arg)) + for token, (action, arg) in actions.items()} + for state, actions in self.states.items() + } + + return { + 'tokens': tokens.reversed(), + 'states': states, + 'start_states': self.start_states, + 'end_states': self.end_states, + } + + @classmethod + def deserialize(cls, data, memo): + tokens = data['tokens'] + states = { + state: {tokens[token]: ((Reduce, Rule.deserialize(arg, memo)) if action==1 else (Shift, arg)) + for token, (action, arg) in actions.items()} + for state, actions in data['states'].items() + } + return cls(states, data['start_states'], data['end_states']) + +class ParseTable(ParseTableBase['State']): + #-- + pass + + +class IntParseTable(ParseTableBase[int]): + #-- + + @classmethod + def from_ParseTable(cls, parse_table: ParseTable): + enum = list(parse_table.states) + state_to_idx: Dict['State', int] = {s:i for i,s in enumerate(enum)} + int_states = {} + + for s, la in parse_table.states.items(): + la = {k:(v[0], state_to_idx[v[1]]) if v[0] is Shift else v + for k,v in la.items()} + int_states[ state_to_idx[s] ] = la + + + start_states = {start:state_to_idx[s] for start, s in parse_table.start_states.items()} + end_states = {start:state_to_idx[s] for start, s in parse_table.end_states.items()} + return cls(int_states, start_states, end_states) + + + +class ParseConf(Generic[StateT]): + __slots__ = 'parse_table', 'callbacks', 'start', 'start_state', 'end_state', 'states' + + parse_table: ParseTableBase[StateT] + callbacks: ParserCallbacks + start: str + + start_state: StateT + end_state: StateT + states: Dict[StateT, Dict[str, tuple]] + + def __init__(self, parse_table: ParseTableBase[StateT], callbacks: ParserCallbacks, start: str): + self.parse_table = parse_table + + self.start_state = self.parse_table.start_states[start] + self.end_state = self.parse_table.end_states[start] + self.states = self.parse_table.states + + self.callbacks = callbacks + self.start = start + +class ParserState(Generic[StateT]): + __slots__ = 'parse_conf', 'lexer', 'state_stack', 'value_stack' + + parse_conf: ParseConf[StateT] + lexer: LexerThread + state_stack: List[StateT] + value_stack: list + + def __init__(self, parse_conf: ParseConf[StateT], lexer: LexerThread, state_stack=None, value_stack=None): + self.parse_conf = parse_conf + self.lexer = lexer + self.state_stack = state_stack or [self.parse_conf.start_state] + self.value_stack = value_stack or [] + + @property + def position(self) -> StateT: + return self.state_stack[-1] + + ## + + def __eq__(self, other) -> bool: + if not isinstance(other, ParserState): + return NotImplemented + return len(self.state_stack) == len(other.state_stack) and self.position == other.position + + def __copy__(self): + return self.copy() + + def copy(self, deepcopy_values=True) -> 'ParserState[StateT]': + return type(self)( + self.parse_conf, + self.lexer, ## + + copy(self.state_stack), + deepcopy(self.value_stack) if deepcopy_values else copy(self.value_stack), + ) + + def feed_token(self, token: Token, is_end=False) -> Any: + state_stack = self.state_stack + value_stack = self.value_stack + states = self.parse_conf.states + end_state = self.parse_conf.end_state + callbacks = self.parse_conf.callbacks + + while True: + state = state_stack[-1] + try: + action, arg = states[state][token.type] + except KeyError: + expected = {s for s in states[state].keys() if s.isupper()} + raise UnexpectedToken(token, expected, state=self, interactive_parser=None) + + assert arg != end_state + + if action is Shift: + ## + + assert not is_end + state_stack.append(arg) + value_stack.append(token if token.type not in callbacks else callbacks[token.type](token)) + return + else: + ## + + rule = arg + size = len(rule.expansion) + if size: + s = value_stack[-size:] + del state_stack[-size:] + del value_stack[-size:] + else: + s = [] + + value = callbacks[rule](s) if callbacks else s + + _action, new_state = states[state_stack[-1]][rule.origin.name] + assert _action is Shift + state_stack.append(new_state) + value_stack.append(value) + + if is_end and state_stack[-1] == end_state: + return value_stack[-1] + + +class LALR_Parser(Serialize): + def __init__(self, parser_conf: ParserConf, debug: bool=False, strict: bool=False): + analysis = LALR_Analyzer(parser_conf, debug=debug, strict=strict) + analysis.compute_lalr() + callbacks = parser_conf.callbacks + + self._parse_table = analysis.parse_table + self.parser_conf = parser_conf + self.parser = _Parser(analysis.parse_table, callbacks, debug) + + @classmethod + def deserialize(cls, data, memo, callbacks, debug=False): + inst = cls.__new__(cls) + inst._parse_table = IntParseTable.deserialize(data, memo) + inst.parser = _Parser(inst._parse_table, callbacks, debug) + return inst + + def serialize(self, memo: Any = None) -> Dict[str, Any]: + return self._parse_table.serialize(memo) + + def parse_interactive(self, lexer: LexerThread, start: str): + return self.parser.parse(lexer, start, start_interactive=True) + + def parse(self, lexer, start, on_error=None): + try: + return self.parser.parse(lexer, start) + except UnexpectedInput as e: + if on_error is None: + raise + + while True: + if isinstance(e, UnexpectedCharacters): + s = e.interactive_parser.lexer_thread.state + p = s.line_ctr.char_pos + + if not on_error(e): + raise e + + if isinstance(e, UnexpectedCharacters): + ## + + if p == s.line_ctr.char_pos: + s.line_ctr.feed(s.text.text[p:p+1]) + + try: + return e.interactive_parser.resume_parse() + except UnexpectedToken as e2: + if (isinstance(e, UnexpectedToken) + and e.token.type == e2.token.type == '$END' + and e.interactive_parser == e2.interactive_parser): + ## + + raise e2 + e = e2 + except UnexpectedCharacters as e2: + e = e2 + + +class _Parser: + parse_table: ParseTableBase + callbacks: ParserCallbacks + debug: bool + + def __init__(self, parse_table: ParseTableBase, callbacks: ParserCallbacks, debug: bool=False): + self.parse_table = parse_table + self.callbacks = callbacks + self.debug = debug + + def parse(self, lexer: LexerThread, start: str, value_stack=None, state_stack=None, start_interactive=False): + parse_conf = ParseConf(self.parse_table, self.callbacks, start) + parser_state = ParserState(parse_conf, lexer, state_stack, value_stack) + if start_interactive: + return InteractiveParser(self, parser_state, parser_state.lexer) + return self.parse_from_state(parser_state) + + + def parse_from_state(self, state: ParserState, last_token: Optional[Token]=None): + #-- + try: + token = last_token + for token in state.lexer.lex(state): + assert token is not None + state.feed_token(token) + + end_token = Token.new_borrow_pos('$END', '', token) if token else Token('$END', '', 0, 1, 1) + return state.feed_token(end_token, True) + except UnexpectedInput as e: + try: + e.interactive_parser = InteractiveParser(self, state, state.lexer) + except NameError: + pass + raise e + except Exception as e: + if self.debug: + print("") + print("STATE STACK DUMP") + print("----------------") + for i, s in enumerate(state.state_stack): + print('%d)' % i , s) + print("") + + raise + + +class InteractiveParser: + #-- + def __init__(self, parser, parser_state: ParserState, lexer_thread: LexerThread): + self.parser = parser + self.parser_state = parser_state + self.lexer_thread = lexer_thread + self.result = None + + @property + def lexer_state(self) -> LexerThread: + warnings.warn("lexer_state will be removed in subsequent releases. Use lexer_thread instead.", DeprecationWarning) + return self.lexer_thread + + def feed_token(self, token: Token): + #-- + return self.parser_state.feed_token(token, token.type == '$END') + + def iter_parse(self) -> Iterator[Token]: + #-- + for token in self.lexer_thread.lex(self.parser_state): + yield token + self.result = self.feed_token(token) + + def exhaust_lexer(self) -> List[Token]: + #-- + return list(self.iter_parse()) + + + def feed_eof(self, last_token=None): + #-- + eof = Token.new_borrow_pos('$END', '', last_token) if last_token is not None else self.lexer_thread._Token('$END', '', 0, 1, 1) + return self.feed_token(eof) + + + def __copy__(self): + #-- + return self.copy() + + def copy(self, deepcopy_values=True): + return type(self)( + self.parser, + self.parser_state.copy(deepcopy_values=deepcopy_values), + copy(self.lexer_thread), + ) + + def __eq__(self, other): + if not isinstance(other, InteractiveParser): + return False + + return self.parser_state == other.parser_state and self.lexer_thread == other.lexer_thread + + def as_immutable(self): + #-- + p = copy(self) + return ImmutableInteractiveParser(p.parser, p.parser_state, p.lexer_thread) + + def pretty(self): + #-- + out = ["Parser choices:"] + for k, v in self.choices().items(): + out.append('\t- %s -> %r' % (k, v)) + out.append('stack size: %s' % len(self.parser_state.state_stack)) + return '\n'.join(out) + + def choices(self): + #-- + return self.parser_state.parse_conf.parse_table.states[self.parser_state.position] + + def accepts(self): + #-- + accepts = set() + conf_no_callbacks = copy(self.parser_state.parse_conf) + ## + + ## + + conf_no_callbacks.callbacks = {} + for t in self.choices(): + if t.isupper(): ## + + new_cursor = self.copy(deepcopy_values=False) + new_cursor.parser_state.parse_conf = conf_no_callbacks + try: + new_cursor.feed_token(self.lexer_thread._Token(t, '')) + except UnexpectedToken: + pass + else: + accepts.add(t) + return accepts + + def resume_parse(self): + #-- + return self.parser.parse_from_state(self.parser_state, last_token=self.lexer_thread.state.last_token) + + + +class ImmutableInteractiveParser(InteractiveParser): + #-- + + result = None + + def __hash__(self): + return hash((self.parser_state, self.lexer_thread)) + + def feed_token(self, token): + c = copy(self) + c.result = InteractiveParser.feed_token(c, token) + return c + + def exhaust_lexer(self): + #-- + cursor = self.as_mutable() + cursor.exhaust_lexer() + return cursor.as_immutable() + + def as_mutable(self): + #-- + p = copy(self) + return InteractiveParser(p.parser, p.parser_state, p.lexer_thread) + + + +def _wrap_lexer(lexer_class): + future_interface = getattr(lexer_class, '__future_interface__', 0) + if future_interface == 2: + return lexer_class + elif future_interface == 1: + class CustomLexerWrapper1(Lexer): + def __init__(self, lexer_conf): + self.lexer = lexer_class(lexer_conf) + def lex(self, lexer_state, parser_state): + if isinstance(lexer_state.text, TextSlice) and not lexer_state.text.is_complete_text(): + raise TypeError("Interface=1 Custom Lexer don't support TextSlice") + lexer_state.text = lexer_state.text + return self.lexer.lex(lexer_state, parser_state) + return CustomLexerWrapper1 + elif future_interface == 0: + class CustomLexerWrapper0(Lexer): + def __init__(self, lexer_conf): + self.lexer = lexer_class(lexer_conf) + + def lex(self, lexer_state, parser_state): + if isinstance(lexer_state.text, TextSlice): + if not lexer_state.text.is_complete_text(): + raise TypeError("Interface=0 Custom Lexer don't support TextSlice") + return self.lexer.lex(lexer_state.text.text) + return self.lexer.lex(lexer_state.text) + return CustomLexerWrapper0 + else: + raise ValueError(f"Unknown __future_interface__ value {future_interface}, integer 0-2 expected") + + +def _deserialize_parsing_frontend(data, memo, lexer_conf, callbacks, options): + parser_conf = ParserConf.deserialize(data['parser_conf'], memo) + cls = (options and options._plugins.get('LALR_Parser')) or LALR_Parser + parser = cls.deserialize(data['parser'], memo, callbacks, options.debug) + parser_conf.callbacks = callbacks + return ParsingFrontend(lexer_conf, parser_conf, options, parser=parser) + + +_parser_creators: 'Dict[str, Callable[[LexerConf, Any, Any], Any]]' = {} + + +class ParsingFrontend(Serialize): + __serialize_fields__ = 'lexer_conf', 'parser_conf', 'parser' + + lexer_conf: LexerConf + parser_conf: ParserConf + options: Any + + def __init__(self, lexer_conf: LexerConf, parser_conf: ParserConf, options, parser=None): + self.parser_conf = parser_conf + self.lexer_conf = lexer_conf + self.options = options + + ## + + if parser: ## + + self.parser = parser + else: + create_parser = _parser_creators.get(parser_conf.parser_type) + assert create_parser is not None, "{} is not supported in standalone mode".format( + parser_conf.parser_type + ) + self.parser = create_parser(lexer_conf, parser_conf, options) + + ## + + lexer_type = lexer_conf.lexer_type + self.skip_lexer = False + if lexer_type in ('dynamic', 'dynamic_complete'): + assert lexer_conf.postlex is None + self.skip_lexer = True + return + + if isinstance(lexer_type, type): + assert issubclass(lexer_type, Lexer) + self.lexer = _wrap_lexer(lexer_type)(lexer_conf) + elif isinstance(lexer_type, str): + create_lexer = { + 'basic': create_basic_lexer, + 'contextual': create_contextual_lexer, + }[lexer_type] + self.lexer = create_lexer(lexer_conf, self.parser, lexer_conf.postlex, options) + else: + raise TypeError("Bad value for lexer_type: {lexer_type}") + + if lexer_conf.postlex: + self.lexer = PostLexConnector(self.lexer, lexer_conf.postlex) + + def _verify_start(self, start=None): + if start is None: + start_decls = self.parser_conf.start + if len(start_decls) > 1: + raise ConfigurationError("Lark initialized with more than 1 possible start rule. Must specify which start rule to parse", start_decls) + start ,= start_decls + elif start not in self.parser_conf.start: + raise ConfigurationError("Unknown start rule %s. Must be one of %r" % (start, self.parser_conf.start)) + return start + + def _make_lexer_thread(self, text: Optional[LarkInput]) -> Union[LarkInput, LexerThread, None]: + cls = (self.options and self.options._plugins.get('LexerThread')) or LexerThread + if self.skip_lexer: + return text + if text is None: + return cls(self.lexer, None) + if isinstance(text, (str, bytes, TextSlice)): + return cls.from_text(self.lexer, text) + return cls.from_custom_input(self.lexer, text) + + def parse(self, text: Optional[LarkInput], start=None, on_error=None): + if self.lexer_conf.lexer_type in ("dynamic", "dynamic_complete"): + if isinstance(text, TextSlice) and not text.is_complete_text(): + raise TypeError(f"Lexer {self.lexer_conf.lexer_type} does not support text slices.") + + chosen_start = self._verify_start(start) + kw = {} if on_error is None else {'on_error': on_error} + stream = self._make_lexer_thread(text) + return self.parser.parse(stream, chosen_start, **kw) + + def parse_interactive(self, text: Optional[TextOrSlice]=None, start=None): + ## + + ## + + chosen_start = self._verify_start(start) + if self.parser_conf.parser_type != 'lalr': + raise ConfigurationError("parse_interactive() currently only works with parser='lalr' ") + stream = self._make_lexer_thread(text) + return self.parser.parse_interactive(stream, chosen_start) + + +def _validate_frontend_args(parser, lexer) -> None: + assert_config(parser, ('lalr', 'earley', 'cyk')) + if not isinstance(lexer, type): ## + + expected = { + 'lalr': ('basic', 'contextual'), + 'earley': ('basic', 'dynamic', 'dynamic_complete'), + 'cyk': ('basic', ), + }[parser] + assert_config(lexer, expected, 'Parser %r does not support lexer %%r, expected one of %%s' % parser) + + +def _get_lexer_callbacks(transformer, terminals): + result = {} + for terminal in terminals: + callback = getattr(transformer, terminal.name, None) + if callback is not None: + result[terminal.name] = callback + return result + +class PostLexConnector: + def __init__(self, lexer, postlexer): + self.lexer = lexer + self.postlexer = postlexer + + def lex(self, lexer_state, parser_state): + i = self.lexer.lex(lexer_state, parser_state) + return self.postlexer.process(i) + + + +def create_basic_lexer(lexer_conf, parser, postlex, options) -> BasicLexer: + cls = (options and options._plugins.get('BasicLexer')) or BasicLexer + return cls(lexer_conf) + +def create_contextual_lexer(lexer_conf: LexerConf, parser, postlex, options) -> ContextualLexer: + cls = (options and options._plugins.get('ContextualLexer')) or ContextualLexer + parse_table: ParseTableBase[int] = parser._parse_table + states: Dict[int, Collection[str]] = {idx:list(t.keys()) for idx, t in parse_table.states.items()} + always_accept: Collection[str] = postlex.always_accept if postlex else () + return cls(lexer_conf, states, always_accept=always_accept) + +def create_lalr_parser(lexer_conf: LexerConf, parser_conf: ParserConf, options=None) -> LALR_Parser: + debug = options.debug if options else False + strict = options.strict if options else False + cls = (options and options._plugins.get('LALR_Parser')) or LALR_Parser + return cls(parser_conf, debug=debug, strict=strict) + +_parser_creators['lalr'] = create_lalr_parser + + + + +class PostLex(ABC): + @abstractmethod + def process(self, stream: Iterator[Token]) -> Iterator[Token]: + return stream + + always_accept: Iterable[str] = () + +class LarkOptions(Serialize): + #-- + + start: List[str] + debug: bool + strict: bool + transformer: 'Optional[Transformer]' + propagate_positions: Union[bool, str] + maybe_placeholders: bool + cache: Union[bool, str] + cache_grammar: bool + regex: bool + g_regex_flags: int + keep_all_tokens: bool + tree_class: Optional[Callable[[str, List], Any]] + parser: _ParserArgType + lexer: _LexerArgType + ambiguity: 'Literal["auto", "resolve", "explicit", "forest"]' + postlex: Optional[PostLex] + priority: 'Optional[Literal["auto", "normal", "invert"]]' + lexer_callbacks: Dict[str, Callable[[Token], Token]] + use_bytes: bool + ordered_sets: bool + edit_terminals: Optional[Callable[[TerminalDef], TerminalDef]] + import_paths: 'List[Union[str, Callable[[Union[None, str, PackageResource], str], Tuple[str, str]]]]' + source_path: Optional[str] + + OPTIONS_DOC = r""" + **=== General Options ===** + + start + The start symbol. Either a string, or a list of strings for multiple possible starts (Default: "start") + debug + Display debug information and extra warnings. Use only when debugging (Default: ``False``) + When used with Earley, it generates a forest graph as "sppf.png", if 'dot' is installed. + strict + Throw an exception on any potential ambiguity, including shift/reduce conflicts, and regex collisions. + transformer + Applies the transformer to every parse tree (equivalent to applying it after the parse, but faster) + propagate_positions + Propagates positional attributes into the 'meta' attribute of all tree branches. + Sets attributes: (line, column, end_line, end_column, start_pos, end_pos, + container_line, container_column, container_end_line, container_end_column) + Accepts ``False``, ``True``, or a callable, which will filter which nodes to ignore when propagating. + maybe_placeholders + When ``True``, the ``[]`` operator returns ``None`` when not matched. + When ``False``, ``[]`` behaves like the ``?`` operator, and returns no value at all. + (default= ``True``) + cache + Cache the results of the Lark grammar analysis, for x2 to x3 faster loading. LALR only for now. + + - When ``False``, does nothing (default) + - When ``True``, caches to a temporary file in the local directory + - When given a string, caches to the path pointed by the string + cache_grammar + For use with ``cache`` option. When ``True``, the unanalyzed grammar is also included in the cache. + Useful for classes that require the ``Lark.grammar`` to be present (e.g. Reconstructor). + (default= ``False``) + regex + When True, uses the ``regex`` module instead of the stdlib ``re``. + g_regex_flags + Flags that are applied to all terminals (both regex and strings) + keep_all_tokens + Prevent the tree builder from automagically removing "punctuation" tokens (Default: ``False``) + tree_class + Lark will produce trees comprised of instances of this class instead of the default ``lark.Tree``. + + **=== Algorithm Options ===** + + parser + Decides which parser engine to use. Accepts "earley" or "lalr". (Default: "earley"). + (there is also a "cyk" option for legacy) + lexer + Decides whether or not to use a lexer stage + + - "auto" (default): Choose for me based on the parser + - "basic": Use a basic lexer + - "contextual": Stronger lexer (only works with parser="lalr") + - "dynamic": Flexible and powerful (only with parser="earley") + - "dynamic_complete": Same as dynamic, but tries *every* variation of tokenizing possible. + ambiguity + Decides how to handle ambiguity in the parse. Only relevant if parser="earley" + + - "resolve": The parser will automatically choose the simplest derivation + (it chooses consistently: greedy for tokens, non-greedy for rules) + - "explicit": The parser will return all derivations wrapped in "_ambig" tree nodes (i.e. a forest). + - "forest": The parser will return the root of the shared packed parse forest. + + **=== Misc. / Domain Specific Options ===** + + postlex + Lexer post-processing (Default: ``None``) Only works with the basic and contextual lexers. + priority + How priorities should be evaluated - "auto", ``None``, "normal", "invert" (Default: "auto") + lexer_callbacks + Dictionary of callbacks for the lexer. May alter tokens during lexing. Use with caution. + use_bytes + Accept an input of type ``bytes`` instead of ``str``. + ordered_sets + Should Earley use ordered-sets to achieve stable output (~10% slower than regular sets. Default: True) + edit_terminals + A callback for editing the terminals before parse. + import_paths + A List of either paths or loader functions to specify from where grammars are imported + source_path + Override the source of from where the grammar was loaded. Useful for relative imports and unconventional grammar loading + **=== End of Options ===** + """ + if __doc__: + __doc__ += OPTIONS_DOC + + + ## + + ## + + ## + + ## + + ## + + ## + + _defaults: Dict[str, Any] = { + 'debug': False, + 'strict': False, + 'keep_all_tokens': False, + 'tree_class': None, + 'cache': False, + 'cache_grammar': False, + 'postlex': None, + 'parser': 'earley', + 'lexer': 'auto', + 'transformer': None, + 'start': 'start', + 'priority': 'auto', + 'ambiguity': 'auto', + 'regex': False, + 'propagate_positions': False, + 'lexer_callbacks': {}, + 'maybe_placeholders': True, + 'edit_terminals': None, + 'g_regex_flags': 0, + 'use_bytes': False, + 'ordered_sets': True, + 'import_paths': [], + 'source_path': None, + '_plugins': {}, + } + + def __init__(self, options_dict: Dict[str, Any]) -> None: + o = dict(options_dict) + + options = {} + for name, default in self._defaults.items(): + if name in o: + value = o.pop(name) + if isinstance(default, bool) and name not in ('cache', 'use_bytes', 'propagate_positions'): + value = bool(value) + else: + value = default + + options[name] = value + + if isinstance(options['start'], str): + options['start'] = [options['start']] + + self.__dict__['options'] = options + + + assert_config(self.parser, ('earley', 'lalr', 'cyk', None)) + + if self.parser == 'earley' and self.transformer: + raise ConfigurationError('Cannot specify an embedded transformer when using the Earley algorithm. ' + 'Please use your transformer on the resulting parse tree, or use a different algorithm (i.e. LALR)') + + if self.cache_grammar and not self.cache: + raise ConfigurationError('cache_grammar cannot be set when cache is disabled') + + if o: + raise ConfigurationError("Unknown options: %s" % o.keys()) + + def __getattr__(self, name: str) -> Any: + try: + return self.__dict__['options'][name] + except KeyError as e: + raise AttributeError(e) + + def __setattr__(self, name: str, value: str) -> None: + assert_config(name, self.options.keys(), "%r isn't a valid option. Expected one of: %s") + self.options[name] = value + + def serialize(self, memo = None) -> Dict[str, Any]: + return self.options + + @classmethod + def deserialize(cls, data: Dict[str, Any], memo: Dict[int, Union[TerminalDef, Rule]]) -> "LarkOptions": + return cls(data) + + +## + +## + +_LOAD_ALLOWED_OPTIONS = {'postlex', 'transformer', 'lexer_callbacks', 'use_bytes', 'debug', 'g_regex_flags', 'regex', 'propagate_positions', 'tree_class', '_plugins'} + +_VALID_PRIORITY_OPTIONS = ('auto', 'normal', 'invert', None) +_VALID_AMBIGUITY_OPTIONS = ('auto', 'resolve', 'explicit', 'forest') + + +_T = TypeVar('_T', bound="Lark") + +class Lark(Serialize): + #-- + + source_path: str + source_grammar: str + grammar: 'Grammar' + options: LarkOptions + lexer: Lexer + parser: 'ParsingFrontend' + terminals: Collection[TerminalDef] + + __serialize_fields__ = ['parser', 'rules', 'options'] + + def __init__(self, grammar: 'Union[Grammar, str, IO[str]]', **options) -> None: + self.options = LarkOptions(options) + re_module: types.ModuleType + + ## + + if self.options.cache_grammar: + self.__serialize_fields__ = self.__serialize_fields__ + ['grammar'] + + ## + + use_regex = self.options.regex + if use_regex: + if _has_regex: + re_module = regex + else: + raise ImportError('`regex` module must be installed if calling `Lark(regex=True)`.') + else: + re_module = re + + ## + + if self.options.source_path is None: + try: + self.source_path = grammar.name ## + + except AttributeError: + self.source_path = '' + else: + self.source_path = self.options.source_path + + ## + + try: + read = grammar.read ## + + except AttributeError: + pass + else: + grammar = read() + + cache_fn = None + cache_sha256 = None + if isinstance(grammar, str): + self.source_grammar = grammar + if self.options.use_bytes: + if not grammar.isascii(): + raise ConfigurationError("Grammar must be ascii only, when use_bytes=True") + + if self.options.cache: + if self.options.parser != 'lalr': + raise ConfigurationError("cache only works with parser='lalr' for now") + + unhashable = ('transformer', 'postlex', 'lexer_callbacks', 'edit_terminals', '_plugins') + options_str = ''.join(k+str(v) for k, v in options.items() if k not in unhashable) + from . import __version__ + s = grammar + options_str + __version__ + str(sys.version_info[:2]) + cache_sha256 = sha256_digest(s) + + if isinstance(self.options.cache, str): + cache_fn = self.options.cache + else: + if self.options.cache is not True: + raise ConfigurationError("cache argument must be bool or str") + + try: + username = getpass.getuser() + except Exception: + ## + + ## + + ## + + username = "unknown" + + + cache_fn = tempfile.gettempdir() + "/.lark_%s_%s_%s_%s_%s.tmp" % ( + "cache_grammar" if self.options.cache_grammar else "cache", username, cache_sha256, *sys.version_info[:2]) + + old_options = self.options + try: + with FS.open(cache_fn, 'rb') as f: + logger.debug('Loading grammar from cache: %s', cache_fn) + ## + + for name in (set(options) - _LOAD_ALLOWED_OPTIONS): + del options[name] + file_sha256 = f.readline().rstrip(b'\n') + cached_used_files = pickle.load(f) + if file_sha256 == cache_sha256.encode('utf8') and verify_used_files(cached_used_files): + cached_parser_data = pickle.load(f) + self._load(cached_parser_data, **options) + return + except FileNotFoundError: + ## + + pass + except Exception: ## + + logger.exception("Failed to load Lark from cache: %r. We will try to carry on.", cache_fn) + + ## + + ## + + self.options = old_options + + + ## + + self.grammar, used_files = load_grammar(grammar, self.source_path, self.options.import_paths, self.options.keep_all_tokens) + else: + assert isinstance(grammar, Grammar) + self.grammar = grammar + + + if self.options.lexer == 'auto': + if self.options.parser == 'lalr': + self.options.lexer = 'contextual' + elif self.options.parser == 'earley': + if self.options.postlex is not None: + logger.info("postlex can't be used with the dynamic lexer, so we use 'basic' instead. " + "Consider using lalr with contextual instead of earley") + self.options.lexer = 'basic' + else: + self.options.lexer = 'dynamic' + elif self.options.parser == 'cyk': + self.options.lexer = 'basic' + else: + assert False, self.options.parser + lexer = self.options.lexer + if isinstance(lexer, type): + assert issubclass(lexer, Lexer) ## + + else: + assert_config(lexer, ('basic', 'contextual', 'dynamic', 'dynamic_complete')) + if self.options.postlex is not None and 'dynamic' in lexer: + raise ConfigurationError("Can't use postlex with a dynamic lexer. Use basic or contextual instead") + + if self.options.ambiguity == 'auto': + if self.options.parser == 'earley': + self.options.ambiguity = 'resolve' + else: + assert_config(self.options.parser, ('earley', 'cyk'), "%r doesn't support disambiguation. Use one of these parsers instead: %s") + + if self.options.priority == 'auto': + self.options.priority = 'normal' + + if self.options.priority not in _VALID_PRIORITY_OPTIONS: + raise ConfigurationError("invalid priority option: %r. Must be one of %r" % (self.options.priority, _VALID_PRIORITY_OPTIONS)) + if self.options.ambiguity not in _VALID_AMBIGUITY_OPTIONS: + raise ConfigurationError("invalid ambiguity option: %r. Must be one of %r" % (self.options.ambiguity, _VALID_AMBIGUITY_OPTIONS)) + + if self.options.parser is None: + terminals_to_keep = '*' ## + + elif self.options.postlex is not None: + terminals_to_keep = set(self.options.postlex.always_accept) + else: + terminals_to_keep = set() + + ## + + self.terminals, self.rules, self.ignore_tokens = self.grammar.compile(self.options.start, terminals_to_keep) + + if self.options.edit_terminals: + for t in self.terminals: + self.options.edit_terminals(t) + + self._terminals_dict = {t.name: t for t in self.terminals} + + ## + + if self.options.priority == 'invert': + for rule in self.rules: + if rule.options.priority is not None: + rule.options.priority = -rule.options.priority + for term in self.terminals: + term.priority = -term.priority + ## + + ## + + ## + + elif self.options.priority is None: + for rule in self.rules: + if rule.options.priority is not None: + rule.options.priority = None + for term in self.terminals: + term.priority = 0 + + ## + + self.lexer_conf = LexerConf( + self.terminals, re_module, self.ignore_tokens, self.options.postlex, + self.options.lexer_callbacks, self.options.g_regex_flags, use_bytes=self.options.use_bytes, strict=self.options.strict + ) + + if self.options.parser: + self.parser = self._build_parser() + elif lexer: + self.lexer = self._build_lexer() + + if cache_fn: + logger.debug('Saving grammar to cache: %s', cache_fn) + try: + with FS.open(cache_fn, 'wb') as f: + assert cache_sha256 is not None + f.write(cache_sha256.encode('utf8') + b'\n') + pickle.dump(used_files, f) + self.save(f, _LOAD_ALLOWED_OPTIONS) + except IOError as e: + logger.exception("Failed to save Lark to cache: %r.", cache_fn, e) + + if __doc__: + __doc__ += "\n\n" + LarkOptions.OPTIONS_DOC + + def _build_lexer(self, dont_ignore: bool=False) -> BasicLexer: + lexer_conf = self.lexer_conf + if dont_ignore: + from copy import copy + lexer_conf = copy(lexer_conf) + lexer_conf.ignore = () + return BasicLexer(lexer_conf) + + def _prepare_callbacks(self) -> None: + self._callbacks = {} + ## + + if self.options.ambiguity != 'forest': + self._parse_tree_builder = ParseTreeBuilder( + self.rules, + self.options.tree_class or Tree, + self.options.propagate_positions, + self.options.parser != 'lalr' and self.options.ambiguity == 'explicit', + self.options.maybe_placeholders + ) + self._callbacks = self._parse_tree_builder.create_callback(self.options.transformer) + self._callbacks.update(_get_lexer_callbacks(self.options.transformer, self.terminals)) + + def _build_parser(self) -> "ParsingFrontend": + self._prepare_callbacks() + _validate_frontend_args(self.options.parser, self.options.lexer) + parser_conf = ParserConf(self.rules, self._callbacks, self.options.start) + return _construct_parsing_frontend( + self.options.parser, + self.options.lexer, + self.lexer_conf, + parser_conf, + options=self.options + ) + + def save(self, f, exclude_options: Collection[str] = ()) -> None: + #-- + if self.options.parser != 'lalr': + raise NotImplementedError("Lark.save() is only implemented for the LALR(1) parser.") + data, m = self.memo_serialize([TerminalDef, Rule]) + if exclude_options: + data["options"] = {n: v for n, v in data["options"].items() if n not in exclude_options} + pickle.dump({'data': data, 'memo': m}, f, protocol=pickle.HIGHEST_PROTOCOL) + + @classmethod + def load(cls: Type[_T], f) -> _T: + #-- + inst = cls.__new__(cls) + return inst._load(f) + + def _deserialize_lexer_conf(self, data: Dict[str, Any], memo: Dict[int, Union[TerminalDef, Rule]], options: LarkOptions) -> LexerConf: + lexer_conf = LexerConf.deserialize(data['lexer_conf'], memo) + lexer_conf.callbacks = options.lexer_callbacks or {} + lexer_conf.re_module = regex if options.regex else re + lexer_conf.use_bytes = options.use_bytes + lexer_conf.g_regex_flags = options.g_regex_flags + lexer_conf.skip_validation = True + lexer_conf.postlex = options.postlex + return lexer_conf + + def _load(self: _T, f: Any, **kwargs) -> _T: + if isinstance(f, dict): + d = f + else: + d = pickle.load(f) + memo_json = d['memo'] + data = d['data'] + + assert memo_json + memo = SerializeMemoizer.deserialize(memo_json, {'Rule': Rule, 'TerminalDef': TerminalDef}, {}) + if 'grammar' in data: + self.grammar = Grammar.deserialize(data['grammar'], memo) + options = dict(data['options']) + if (set(kwargs) - _LOAD_ALLOWED_OPTIONS) & set(LarkOptions._defaults): + raise ConfigurationError("Some options are not allowed when loading a Parser: {}" + .format(set(kwargs) - _LOAD_ALLOWED_OPTIONS)) + options.update(kwargs) + self.options = LarkOptions.deserialize(options, memo) + self.rules = [Rule.deserialize(r, memo) for r in data['rules']] + self.source_path = '' + _validate_frontend_args(self.options.parser, self.options.lexer) + self.lexer_conf = self._deserialize_lexer_conf(data['parser'], memo, self.options) + self.terminals = self.lexer_conf.terminals + self._prepare_callbacks() + self._terminals_dict = {t.name: t for t in self.terminals} + self.parser = _deserialize_parsing_frontend( + data['parser'], + memo, + self.lexer_conf, + self._callbacks, + self.options, ## + + ) + return self + + @classmethod + def _load_from_dict(cls, data, memo, **kwargs): + inst = cls.__new__(cls) + return inst._load({'data': data, 'memo': memo}, **kwargs) + + @classmethod + def open(cls: Type[_T], grammar_filename: str, rel_to: Optional[str]=None, **options) -> _T: + #-- + if rel_to: + basepath = os.path.dirname(rel_to) + grammar_filename = os.path.join(basepath, grammar_filename) + with open(grammar_filename, encoding='utf8') as f: + return cls(f, **options) + + @classmethod + def open_from_package(cls: Type[_T], package: str, grammar_path: str, search_paths: 'Sequence[str]'=[""], **options) -> _T: + #-- + package_loader = FromPackageLoader(package, search_paths) + full_path, text = package_loader(None, grammar_path) + options.setdefault('source_path', full_path) + options.setdefault('import_paths', []) + options['import_paths'].append(package_loader) + return cls(text, **options) + + def __repr__(self): + return 'Lark(open(%r), parser=%r, lexer=%r, ...)' % (self.source_path, self.options.parser, self.options.lexer) + + + def lex(self, text: TextOrSlice, dont_ignore: bool=False) -> Iterator[Token]: + #-- + lexer: Lexer + if not hasattr(self, 'lexer') or dont_ignore: + lexer = self._build_lexer(dont_ignore) + else: + lexer = self.lexer + lexer_thread = LexerThread.from_text(lexer, text) + stream = lexer_thread.lex(None) + if self.options.postlex: + return self.options.postlex.process(stream) + return stream + + def get_terminal(self, name: str) -> TerminalDef: + #-- + return self._terminals_dict[name] + + def parse_interactive(self, text: Optional[LarkInput]=None, start: Optional[str]=None) -> 'InteractiveParser': + #-- + return self.parser.parse_interactive(text, start=start) + + def parse(self, text: LarkInput, start: Optional[str]=None, on_error: 'Optional[Callable[[UnexpectedInput], bool]]'=None) -> 'ParseTree': + #-- + if on_error is not None and self.options.parser != 'lalr': + raise NotImplementedError("The on_error option is only implemented for the LALR(1) parser.") + return self.parser.parse(text, start=start, on_error=on_error) + + + + +class DedentError(LarkError): + pass + +class Indenter(PostLex, ABC): + #-- + paren_level: int + indent_level: List[int] + + def __init__(self) -> None: + self.paren_level = 0 + self.indent_level = [0] + assert self.tab_len > 0 + + def handle_NL(self, token: Token) -> Iterator[Token]: + if self.paren_level > 0: + return + + yield token + + indent_str = token.rsplit('\n', 1)[1] ## + + indent = indent_str.count(' ') + indent_str.count('\t') * self.tab_len + + if indent > self.indent_level[-1]: + self.indent_level.append(indent) + yield Token.new_borrow_pos(self.INDENT_type, indent_str, token) + else: + while indent < self.indent_level[-1]: + self.indent_level.pop() + yield Token.new_borrow_pos(self.DEDENT_type, indent_str, token) + + if indent != self.indent_level[-1]: + raise DedentError('Unexpected dedent to column %s. Expected dedent to %s' % (indent, self.indent_level[-1])) + + def _process(self, stream): + token = None + for token in stream: + if token.type == self.NL_type: + yield from self.handle_NL(token) + else: + yield token + + if token.type in self.OPEN_PAREN_types: + self.paren_level += 1 + elif token.type in self.CLOSE_PAREN_types: + self.paren_level -= 1 + assert self.paren_level >= 0 + + while len(self.indent_level) > 1: + self.indent_level.pop() + yield Token.new_borrow_pos(self.DEDENT_type, '', token) if token else Token(self.DEDENT_type, '', 0, 0, 0, 0, 0, 0) + + assert self.indent_level == [0], self.indent_level + + def process(self, stream): + self.paren_level = 0 + self.indent_level = [0] + return self._process(stream) + + ## + + @property + def always_accept(self): + return (self.NL_type,) + + @property + @abstractmethod + def NL_type(self) -> str: + #-- + raise NotImplementedError() + + @property + @abstractmethod + def OPEN_PAREN_types(self) -> List[str]: + #-- + raise NotImplementedError() + + @property + @abstractmethod + def CLOSE_PAREN_types(self) -> List[str]: + #-- + raise NotImplementedError() + + @property + @abstractmethod + def INDENT_type(self) -> str: + #-- + raise NotImplementedError() + + @property + @abstractmethod + def DEDENT_type(self) -> str: + #-- + raise NotImplementedError() + + @property + @abstractmethod + def tab_len(self) -> int: + #-- + raise NotImplementedError() + + +class PythonIndenter(Indenter): + #-- + + NL_type = '_NEWLINE' + OPEN_PAREN_types = ['LPAR', 'LSQB', 'LBRACE'] + CLOSE_PAREN_types = ['RPAR', 'RSQB', 'RBRACE'] + INDENT_type = '_INDENT' + DEDENT_type = '_DEDENT' + tab_len = 8 + + +import pickle, zlib, base64 +DATA = ( +{'parser': {'lexer_conf': {'terminals': [{'@': 0}, {'@': 1}, {'@': 2}, {'@': 3}, {'@': 4}, {'@': 5}, {'@': 6}, {'@': 7}, {'@': 8}, {'@': 9}, {'@': 10}, {'@': 11}, {'@': 12}, {'@': 13}, {'@': 14}, {'@': 15}, {'@': 16}, {'@': 17}, {'@': 18}, {'@': 19}, {'@': 20}, {'@': 21}, {'@': 22}, {'@': 23}, {'@': 24}, {'@': 25}, {'@': 26}, {'@': 27}, {'@': 28}, {'@': 29}, {'@': 30}, {'@': 31}, {'@': 32}, {'@': 33}, {'@': 34}, {'@': 35}, {'@': 36}, {'@': 37}, {'@': 38}, {'@': 39}, {'@': 40}, {'@': 41}, {'@': 42}, {'@': 43}, {'@': 44}, {'@': 45}, {'@': 46}, {'@': 47}, {'@': 48}, {'@': 49}, {'@': 50}, {'@': 51}, {'@': 52}, {'@': 53}, {'@': 54}, {'@': 55}, {'@': 56}, {'@': 57}, {'@': 58}, {'@': 59}, {'@': 60}, {'@': 61}, {'@': 62}, {'@': 63}, {'@': 64}, {'@': 65}, {'@': 66}, {'@': 67}, {'@': 68}, {'@': 69}, {'@': 70}, {'@': 71}, {'@': 72}, {'@': 73}, {'@': 74}, {'@': 75}, {'@': 76}, {'@': 77}, {'@': 78}, {'@': 79}, {'@': 80}, {'@': 81}, {'@': 82}, {'@': 83}, {'@': 84}, {'@': 85}, {'@': 86}, {'@': 87}, {'@': 88}, {'@': 89}, {'@': 90}, {'@': 91}, {'@': 92}, {'@': 93}, {'@': 94}, {'@': 95}, {'@': 96}, {'@': 97}, {'@': 98}, {'@': 99}, {'@': 100}, {'@': 101}, {'@': 102}, {'@': 103}, {'@': 104}, {'@': 105}, {'@': 106}, {'@': 107}, {'@': 108}, {'@': 109}, {'@': 110}, {'@': 111}, {'@': 112}, {'@': 113}, {'@': 114}, {'@': 115}, {'@': 116}, {'@': 117}, {'@': 118}, {'@': 119}, {'@': 120}, {'@': 121}, {'@': 122}, {'@': 123}, {'@': 124}, {'@': 125}, {'@': 126}, {'@': 127}, {'@': 128}, {'@': 129}, {'@': 130}, {'@': 131}, {'@': 132}, {'@': 133}, {'@': 134}, {'@': 135}, {'@': 136}, {'@': 137}, {'@': 138}, {'@': 139}, {'@': 140}, {'@': 141}, {'@': 142}, {'@': 143}, {'@': 144}, {'@': 145}, {'@': 146}, {'@': 147}, {'@': 148}, {'@': 149}, {'@': 150}, {'@': 151}, {'@': 152}, {'@': 153}, {'@': 154}, {'@': 155}, {'@': 156}, {'@': 157}, {'@': 158}, {'@': 159}, {'@': 160}, {'@': 161}, {'@': 162}, {'@': 163}, {'@': 164}, {'@': 165}, {'@': 166}, {'@': 167}, {'@': 168}, {'@': 169}, {'@': 170}, {'@': 171}, {'@': 172}, {'@': 173}, {'@': 174}, {'@': 175}, {'@': 176}, {'@': 177}, {'@': 178}, {'@': 179}, {'@': 180}, {'@': 181}, {'@': 182}, {'@': 183}, {'@': 184}, {'@': 185}, {'@': 186}, {'@': 187}, {'@': 188}, {'@': 189}, {'@': 190}, {'@': 191}, {'@': 192}, {'@': 193}, {'@': 194}, {'@': 195}, {'@': 196}, {'@': 197}, {'@': 198}, {'@': 199}, {'@': 200}, {'@': 201}, {'@': 202}, {'@': 203}, {'@': 204}, {'@': 205}, {'@': 206}, {'@': 207}, {'@': 208}, {'@': 209}, {'@': 210}, {'@': 211}, {'@': 212}, {'@': 213}, {'@': 214}, {'@': 215}, {'@': 216}, {'@': 217}, {'@': 218}, {'@': 219}, {'@': 220}, {'@': 221}, {'@': 222}, {'@': 223}, {'@': 224}, {'@': 225}, {'@': 226}, {'@': 227}, {'@': 228}, {'@': 229}, {'@': 230}, {'@': 231}, {'@': 232}, {'@': 233}, {'@': 234}, {'@': 235}, {'@': 236}, {'@': 237}, {'@': 238}, {'@': 239}, {'@': 240}, {'@': 241}, {'@': 242}, {'@': 243}, {'@': 244}, {'@': 245}, {'@': 246}, {'@': 247}, {'@': 248}, {'@': 249}, {'@': 250}, {'@': 251}, {'@': 252}, {'@': 253}, {'@': 254}, {'@': 255}, {'@': 256}, {'@': 257}, {'@': 258}, {'@': 259}, {'@': 260}, {'@': 261}, {'@': 262}, {'@': 263}, {'@': 264}, {'@': 265}, {'@': 266}, {'@': 267}, {'@': 268}, {'@': 269}, {'@': 270}, {'@': 271}, {'@': 272}, {'@': 273}, {'@': 274}, {'@': 275}, {'@': 276}, {'@': 277}, {'@': 278}, {'@': 279}, {'@': 280}, {'@': 281}, {'@': 282}, {'@': 283}, {'@': 284}, {'@': 285}, {'@': 286}, {'@': 287}, {'@': 288}, {'@': 289}, {'@': 290}, {'@': 291}, {'@': 292}, {'@': 293}, {'@': 294}, {'@': 295}, {'@': 296}, {'@': 297}, {'@': 298}, {'@': 299}, {'@': 300}, {'@': 301}, {'@': 302}], 'ignore': ['_WHITESPACE'], 'g_regex_flags': 0, 'use_bytes': False, 'lexer_type': 'contextual', '__type__': 'LexerConf'}, 'parser_conf': {'rules': [{'@': 303}, {'@': 304}, {'@': 305}, {'@': 306}, {'@': 307}, {'@': 308}, {'@': 309}, {'@': 310}, {'@': 311}, {'@': 312}, {'@': 313}, {'@': 314}, {'@': 315}, {'@': 316}, {'@': 317}, {'@': 318}, {'@': 319}, {'@': 320}, {'@': 321}, {'@': 322}, {'@': 323}, {'@': 324}, {'@': 325}, {'@': 326}, {'@': 327}, {'@': 328}, {'@': 329}, {'@': 330}, {'@': 331}, {'@': 332}, {'@': 333}, {'@': 334}, {'@': 335}, {'@': 336}, {'@': 337}, {'@': 338}, {'@': 339}, {'@': 340}, {'@': 341}, {'@': 342}, {'@': 343}, {'@': 344}, {'@': 345}, {'@': 346}, {'@': 347}, {'@': 348}, {'@': 349}, {'@': 350}, {'@': 351}, {'@': 352}, {'@': 353}, {'@': 354}, {'@': 355}, {'@': 356}, {'@': 357}, {'@': 358}, {'@': 359}, {'@': 360}, {'@': 361}, {'@': 362}, {'@': 363}, {'@': 364}, {'@': 365}, {'@': 366}, {'@': 367}, {'@': 368}, {'@': 369}, {'@': 370}, {'@': 371}, {'@': 372}, {'@': 373}, {'@': 374}, {'@': 375}, {'@': 376}, {'@': 377}, {'@': 378}, {'@': 379}, {'@': 380}, {'@': 381}, {'@': 382}, {'@': 383}, {'@': 384}, {'@': 385}, {'@': 386}, {'@': 387}, {'@': 388}, {'@': 389}, {'@': 390}, {'@': 391}, {'@': 392}, {'@': 393}, {'@': 394}, {'@': 395}, {'@': 396}, {'@': 397}, {'@': 398}, {'@': 399}, {'@': 400}, {'@': 401}, {'@': 402}, {'@': 403}, {'@': 404}, {'@': 405}, {'@': 406}, {'@': 407}, {'@': 408}, {'@': 409}, {'@': 410}, {'@': 411}, {'@': 412}, {'@': 413}, {'@': 414}, {'@': 415}, {'@': 416}, {'@': 417}, {'@': 418}, {'@': 419}, {'@': 420}, {'@': 421}, {'@': 422}, {'@': 423}, {'@': 424}, {'@': 425}, {'@': 426}, {'@': 427}, {'@': 428}, {'@': 429}, {'@': 430}, {'@': 431}, {'@': 432}, {'@': 433}, {'@': 434}, {'@': 435}, {'@': 436}, {'@': 437}, {'@': 438}, {'@': 439}, {'@': 440}, {'@': 441}, {'@': 442}, {'@': 443}, {'@': 444}, {'@': 445}, {'@': 446}, {'@': 447}, {'@': 448}, {'@': 449}, {'@': 450}, {'@': 451}, {'@': 452}, {'@': 453}, {'@': 454}, {'@': 455}, {'@': 456}, {'@': 457}, {'@': 458}, {'@': 459}, {'@': 460}, {'@': 461}, {'@': 462}, {'@': 463}, {'@': 464}, {'@': 465}, {'@': 466}, {'@': 467}, {'@': 468}, {'@': 469}, {'@': 470}, {'@': 471}, {'@': 472}, {'@': 473}, {'@': 474}, {'@': 475}, {'@': 476}, {'@': 477}, {'@': 478}, {'@': 479}, {'@': 480}, {'@': 481}, {'@': 482}, {'@': 483}, {'@': 484}, {'@': 485}, {'@': 486}, {'@': 487}, {'@': 488}, {'@': 489}, {'@': 490}, {'@': 491}, {'@': 492}, {'@': 493}, {'@': 494}, {'@': 495}, {'@': 496}, {'@': 497}, {'@': 498}, {'@': 499}, {'@': 500}, {'@': 501}, {'@': 502}, {'@': 503}, {'@': 504}, {'@': 505}, {'@': 506}, {'@': 507}, {'@': 508}, {'@': 509}, {'@': 510}, {'@': 511}, {'@': 512}, {'@': 513}, {'@': 514}, {'@': 515}, {'@': 516}, {'@': 517}, {'@': 518}, {'@': 519}, {'@': 520}, {'@': 521}, {'@': 522}, {'@': 523}, {'@': 524}, {'@': 525}, {'@': 526}, {'@': 527}, {'@': 528}, {'@': 529}, {'@': 530}, {'@': 531}, {'@': 532}, {'@': 533}, {'@': 534}, {'@': 535}, {'@': 536}, {'@': 537}, {'@': 538}, {'@': 539}, {'@': 540}, {'@': 541}, {'@': 542}, {'@': 543}, {'@': 544}, {'@': 545}, {'@': 546}, {'@': 547}, {'@': 548}, {'@': 549}, {'@': 550}, {'@': 551}, {'@': 552}, {'@': 553}, {'@': 554}, {'@': 555}, {'@': 556}, {'@': 557}, {'@': 558}, {'@': 559}, {'@': 560}, {'@': 561}, {'@': 562}, {'@': 563}, {'@': 564}, {'@': 565}, {'@': 566}, {'@': 567}, {'@': 568}, {'@': 569}, {'@': 570}, {'@': 571}, {'@': 572}, {'@': 573}, {'@': 574}, {'@': 575}, {'@': 576}, {'@': 577}, {'@': 578}, {'@': 579}, {'@': 580}, {'@': 581}, {'@': 582}, {'@': 583}, {'@': 584}, {'@': 585}, {'@': 586}, {'@': 587}, {'@': 588}, {'@': 589}, {'@': 590}, {'@': 591}, {'@': 592}, {'@': 593}, {'@': 594}, {'@': 595}, {'@': 596}, {'@': 597}, {'@': 598}, {'@': 599}, {'@': 600}, {'@': 601}, {'@': 602}, {'@': 603}, {'@': 604}, {'@': 605}, {'@': 606}, {'@': 607}, {'@': 608}, {'@': 609}, {'@': 610}, {'@': 611}, {'@': 612}, {'@': 613}, {'@': 614}, {'@': 615}, {'@': 616}, {'@': 617}, {'@': 618}, {'@': 619}, {'@': 620}, {'@': 621}, {'@': 622}, {'@': 623}, {'@': 624}, {'@': 625}, {'@': 626}, {'@': 627}, {'@': 628}, {'@': 629}, {'@': 630}, {'@': 631}, {'@': 632}, {'@': 633}, {'@': 634}, {'@': 635}, {'@': 636}, {'@': 637}, {'@': 638}, {'@': 639}, {'@': 640}, {'@': 641}, {'@': 642}, {'@': 643}, {'@': 644}, {'@': 645}, {'@': 646}, {'@': 647}, {'@': 648}, {'@': 649}, {'@': 650}, {'@': 651}, {'@': 652}, {'@': 653}, {'@': 654}, {'@': 655}, {'@': 656}, {'@': 657}, {'@': 658}, {'@': 659}, {'@': 660}, {'@': 661}, {'@': 662}, {'@': 663}, {'@': 664}, {'@': 665}, {'@': 666}, {'@': 667}, {'@': 668}, {'@': 669}, {'@': 670}, {'@': 671}, {'@': 672}, {'@': 673}, {'@': 674}, {'@': 675}, {'@': 676}, {'@': 677}, {'@': 678}, {'@': 679}, {'@': 680}, {'@': 681}, {'@': 682}, {'@': 683}, {'@': 684}, {'@': 685}, {'@': 686}, {'@': 687}, {'@': 688}, {'@': 689}, {'@': 690}, {'@': 691}, {'@': 692}, {'@': 693}, {'@': 694}, {'@': 695}, {'@': 696}, {'@': 697}, {'@': 698}, {'@': 699}, {'@': 700}, {'@': 701}, {'@': 702}, {'@': 703}, {'@': 704}, {'@': 705}, {'@': 706}, {'@': 707}, {'@': 708}, {'@': 709}, {'@': 710}, {'@': 711}, {'@': 712}, {'@': 713}, {'@': 714}, {'@': 715}, {'@': 716}, {'@': 717}, {'@': 718}, {'@': 719}, {'@': 720}, {'@': 721}, {'@': 722}, {'@': 723}, {'@': 724}, {'@': 725}, {'@': 726}, {'@': 727}, {'@': 728}, {'@': 729}, {'@': 730}, {'@': 731}, {'@': 732}, {'@': 733}, {'@': 734}, {'@': 735}, {'@': 736}, {'@': 737}, {'@': 738}, {'@': 739}, {'@': 740}, {'@': 741}, {'@': 742}, {'@': 743}, {'@': 744}, {'@': 745}, {'@': 746}, {'@': 747}, {'@': 748}, {'@': 749}, {'@': 750}, {'@': 751}, {'@': 752}, {'@': 753}, {'@': 754}, {'@': 755}, {'@': 756}, {'@': 757}, {'@': 758}, {'@': 759}, {'@': 760}, {'@': 761}, {'@': 762}, {'@': 763}, {'@': 764}, {'@': 765}, {'@': 766}, {'@': 767}, {'@': 768}, {'@': 769}, {'@': 770}, {'@': 771}, {'@': 772}, {'@': 773}, {'@': 774}, {'@': 775}, {'@': 776}, {'@': 777}, {'@': 778}, {'@': 779}, {'@': 780}, {'@': 781}, {'@': 782}, {'@': 783}, {'@': 784}, {'@': 785}, {'@': 786}, {'@': 787}, {'@': 788}, {'@': 789}, {'@': 790}, {'@': 791}, {'@': 792}, {'@': 793}, {'@': 794}, {'@': 795}, {'@': 796}, {'@': 797}, {'@': 798}, {'@': 799}, {'@': 800}, {'@': 801}, {'@': 802}, {'@': 803}, {'@': 804}, {'@': 805}, {'@': 806}, {'@': 807}, {'@': 808}, {'@': 809}, {'@': 810}, {'@': 811}, {'@': 812}, {'@': 813}, {'@': 814}, {'@': 815}, {'@': 816}, {'@': 817}, {'@': 818}, {'@': 819}, {'@': 820}, {'@': 821}, {'@': 822}, {'@': 823}, {'@': 824}, {'@': 825}, {'@': 826}, {'@': 827}, {'@': 828}, {'@': 829}, {'@': 830}, {'@': 831}, {'@': 832}, {'@': 833}, {'@': 834}, {'@': 835}, {'@': 836}, {'@': 837}, {'@': 838}, {'@': 839}, {'@': 840}, {'@': 841}, {'@': 842}, {'@': 843}, {'@': 844}, {'@': 845}, {'@': 846}, {'@': 847}, {'@': 848}, {'@': 849}, {'@': 850}, {'@': 851}, {'@': 852}, {'@': 853}, {'@': 854}, {'@': 855}, {'@': 856}, {'@': 857}, {'@': 858}, {'@': 859}, {'@': 860}, {'@': 861}, {'@': 862}, {'@': 863}, {'@': 864}, {'@': 865}, {'@': 866}, {'@': 867}, {'@': 868}, {'@': 869}, {'@': 870}, {'@': 871}, {'@': 872}, {'@': 873}, {'@': 874}, {'@': 875}, {'@': 876}, {'@': 877}, {'@': 878}, {'@': 879}, {'@': 880}, {'@': 881}, {'@': 882}, {'@': 883}, {'@': 884}, {'@': 885}, {'@': 886}, {'@': 887}, {'@': 888}, {'@': 889}, {'@': 890}, {'@': 891}, {'@': 892}, {'@': 893}, {'@': 894}, {'@': 895}, {'@': 896}, {'@': 897}, {'@': 898}, {'@': 899}, {'@': 900}, {'@': 901}, {'@': 902}, {'@': 903}, {'@': 904}, {'@': 905}, {'@': 906}, {'@': 907}, {'@': 908}, {'@': 909}, {'@': 910}, {'@': 911}, {'@': 912}, {'@': 913}, {'@': 914}, {'@': 915}, {'@': 916}, {'@': 917}, {'@': 918}, {'@': 919}, {'@': 920}, {'@': 921}, {'@': 922}, {'@': 923}, {'@': 924}, {'@': 925}, {'@': 926}, {'@': 927}, {'@': 928}, {'@': 929}, {'@': 930}, {'@': 931}, {'@': 932}, {'@': 933}, {'@': 934}, {'@': 935}, {'@': 936}, {'@': 937}, {'@': 938}, {'@': 939}, {'@': 940}, {'@': 941}, {'@': 942}, {'@': 943}, {'@': 944}, {'@': 945}, {'@': 946}, {'@': 947}, {'@': 948}, {'@': 949}, {'@': 950}, {'@': 951}, {'@': 952}, {'@': 953}, {'@': 954}, {'@': 955}, {'@': 956}, {'@': 957}, {'@': 958}, {'@': 959}, {'@': 960}, {'@': 961}, {'@': 962}, {'@': 963}, {'@': 964}, {'@': 965}, {'@': 966}, {'@': 967}, {'@': 968}, {'@': 969}, {'@': 970}, {'@': 971}, {'@': 972}, {'@': 973}, {'@': 974}, {'@': 975}, {'@': 976}, {'@': 977}, {'@': 978}, {'@': 979}, {'@': 980}, {'@': 981}, {'@': 982}, {'@': 983}, {'@': 984}, {'@': 985}, {'@': 986}, {'@': 987}, {'@': 988}, {'@': 989}, {'@': 990}, {'@': 991}, {'@': 992}, {'@': 993}, {'@': 994}, {'@': 995}, {'@': 996}, {'@': 997}, {'@': 998}, {'@': 999}, {'@': 1000}, {'@': 1001}, {'@': 1002}, {'@': 1003}, {'@': 1004}, {'@': 1005}, {'@': 1006}, {'@': 1007}, {'@': 1008}, {'@': 1009}, {'@': 1010}, {'@': 1011}, {'@': 1012}, {'@': 1013}, {'@': 1014}, {'@': 1015}, {'@': 1016}, {'@': 1017}, {'@': 1018}, {'@': 1019}, {'@': 1020}, {'@': 1021}, {'@': 1022}, {'@': 1023}, {'@': 1024}, {'@': 1025}, {'@': 1026}, {'@': 1027}, {'@': 1028}, {'@': 1029}, {'@': 1030}, {'@': 1031}, {'@': 1032}, {'@': 1033}, {'@': 1034}, {'@': 1035}, {'@': 1036}, {'@': 1037}, {'@': 1038}, {'@': 1039}, {'@': 1040}, {'@': 1041}, {'@': 1042}, {'@': 1043}, {'@': 1044}, {'@': 1045}, {'@': 1046}, {'@': 1047}, {'@': 1048}, {'@': 1049}, {'@': 1050}, {'@': 1051}, {'@': 1052}, {'@': 1053}, {'@': 1054}, {'@': 1055}, {'@': 1056}, {'@': 1057}, {'@': 1058}, {'@': 1059}, {'@': 1060}, {'@': 1061}, {'@': 1062}, {'@': 1063}, {'@': 1064}, {'@': 1065}, {'@': 1066}, {'@': 1067}, {'@': 1068}, {'@': 1069}, {'@': 1070}, {'@': 1071}, {'@': 1072}, {'@': 1073}, {'@': 1074}, {'@': 1075}, {'@': 1076}, {'@': 1077}, {'@': 1078}, {'@': 1079}, {'@': 1080}, {'@': 1081}, {'@': 1082}, {'@': 1083}, {'@': 1084}, {'@': 1085}, {'@': 1086}, {'@': 1087}, {'@': 1088}, {'@': 1089}, {'@': 1090}, {'@': 1091}, {'@': 1092}, {'@': 1093}, {'@': 1094}, {'@': 1095}, {'@': 1096}, {'@': 1097}, {'@': 1098}, {'@': 1099}, {'@': 1100}, {'@': 1101}, {'@': 1102}, {'@': 1103}, {'@': 1104}, {'@': 1105}, {'@': 1106}, {'@': 1107}, {'@': 1108}, {'@': 1109}, {'@': 1110}, {'@': 1111}, {'@': 1112}, {'@': 1113}, {'@': 1114}, {'@': 1115}, {'@': 1116}, {'@': 1117}, {'@': 1118}, {'@': 1119}, {'@': 1120}, {'@': 1121}, {'@': 1122}, {'@': 1123}, {'@': 1124}, {'@': 1125}, {'@': 1126}, {'@': 1127}, {'@': 1128}, {'@': 1129}, {'@': 1130}, {'@': 1131}, {'@': 1132}, {'@': 1133}, {'@': 1134}, {'@': 1135}, {'@': 1136}, {'@': 1137}, {'@': 1138}, {'@': 1139}, {'@': 1140}, {'@': 1141}, {'@': 1142}, {'@': 1143}, {'@': 1144}, {'@': 1145}, {'@': 1146}, {'@': 1147}, {'@': 1148}, {'@': 1149}, {'@': 1150}, {'@': 1151}, {'@': 1152}, {'@': 1153}, {'@': 1154}, {'@': 1155}, {'@': 1156}, {'@': 1157}, {'@': 1158}, {'@': 1159}, {'@': 1160}, {'@': 1161}, {'@': 1162}, {'@': 1163}, {'@': 1164}, {'@': 1165}, {'@': 1166}, {'@': 1167}, {'@': 1168}, {'@': 1169}, {'@': 1170}, {'@': 1171}, {'@': 1172}, {'@': 1173}, {'@': 1174}, {'@': 1175}, {'@': 1176}, {'@': 1177}, {'@': 1178}, {'@': 1179}, {'@': 1180}, {'@': 1181}, {'@': 1182}, {'@': 1183}, {'@': 1184}, {'@': 1185}, {'@': 1186}, {'@': 1187}, {'@': 1188}, {'@': 1189}, {'@': 1190}, {'@': 1191}, {'@': 1192}, {'@': 1193}, {'@': 1194}, {'@': 1195}, {'@': 1196}, {'@': 1197}, {'@': 1198}, {'@': 1199}, {'@': 1200}, {'@': 1201}, {'@': 1202}, {'@': 1203}, {'@': 1204}, {'@': 1205}, {'@': 1206}, {'@': 1207}, {'@': 1208}, {'@': 1209}, {'@': 1210}, {'@': 1211}, {'@': 1212}, {'@': 1213}, {'@': 1214}, {'@': 1215}, {'@': 1216}, {'@': 1217}, {'@': 1218}, {'@': 1219}, {'@': 1220}, {'@': 1221}, {'@': 1222}, {'@': 1223}, {'@': 1224}, {'@': 1225}, {'@': 1226}, {'@': 1227}, {'@': 1228}, {'@': 1229}, {'@': 1230}, {'@': 1231}, {'@': 1232}, {'@': 1233}, {'@': 1234}, {'@': 1235}, {'@': 1236}, {'@': 1237}, {'@': 1238}, {'@': 1239}, {'@': 1240}, {'@': 1241}, {'@': 1242}, {'@': 1243}, {'@': 1244}, {'@': 1245}, {'@': 1246}, {'@': 1247}, {'@': 1248}, {'@': 1249}, {'@': 1250}, {'@': 1251}, {'@': 1252}, {'@': 1253}, {'@': 1254}, {'@': 1255}, {'@': 1256}, {'@': 1257}, {'@': 1258}, {'@': 1259}, {'@': 1260}, {'@': 1261}, {'@': 1262}, {'@': 1263}, {'@': 1264}, {'@': 1265}, {'@': 1266}, {'@': 1267}, {'@': 1268}, {'@': 1269}, {'@': 1270}, {'@': 1271}, {'@': 1272}, {'@': 1273}, {'@': 1274}, {'@': 1275}, {'@': 1276}, {'@': 1277}, {'@': 1278}, {'@': 1279}, {'@': 1280}, {'@': 1281}, {'@': 1282}, {'@': 1283}, {'@': 1284}, {'@': 1285}, {'@': 1286}, {'@': 1287}, {'@': 1288}, {'@': 1289}, {'@': 1290}, {'@': 1291}, {'@': 1292}, {'@': 1293}, {'@': 1294}, {'@': 1295}, {'@': 1296}, {'@': 1297}, {'@': 1298}, {'@': 1299}, {'@': 1300}, {'@': 1301}, {'@': 1302}, {'@': 1303}, {'@': 1304}, {'@': 1305}, {'@': 1306}, {'@': 1307}, {'@': 1308}, {'@': 1309}, {'@': 1310}, {'@': 1311}, {'@': 1312}, {'@': 1313}, {'@': 1314}, {'@': 1315}, {'@': 1316}, {'@': 1317}, {'@': 1318}, {'@': 1319}, {'@': 1320}, {'@': 1321}, {'@': 1322}, {'@': 1323}, {'@': 1324}, {'@': 1325}, {'@': 1326}, {'@': 1327}, {'@': 1328}, {'@': 1329}, {'@': 1330}, {'@': 1331}, {'@': 1332}, {'@': 1333}, {'@': 1334}, {'@': 1335}, {'@': 1336}, {'@': 1337}, {'@': 1338}, {'@': 1339}, {'@': 1340}, {'@': 1341}, {'@': 1342}, {'@': 1343}, {'@': 1344}, {'@': 1345}, {'@': 1346}, {'@': 1347}, {'@': 1348}, {'@': 1349}, {'@': 1350}, {'@': 1351}, {'@': 1352}, {'@': 1353}, {'@': 1354}, {'@': 1355}, {'@': 1356}, {'@': 1357}, {'@': 1358}, {'@': 1359}, {'@': 1360}, {'@': 1361}, {'@': 1362}, {'@': 1363}, {'@': 1364}, {'@': 1365}, {'@': 1366}, {'@': 1367}, {'@': 1368}, {'@': 1369}, {'@': 1370}, {'@': 1371}, {'@': 1372}, {'@': 1373}, {'@': 1374}, {'@': 1375}, {'@': 1376}, {'@': 1377}, {'@': 1378}, {'@': 1379}, {'@': 1380}, {'@': 1381}, {'@': 1382}, {'@': 1383}, {'@': 1384}, {'@': 1385}, {'@': 1386}, {'@': 1387}, {'@': 1388}, {'@': 1389}, {'@': 1390}, {'@': 1391}, {'@': 1392}, {'@': 1393}, {'@': 1394}, {'@': 1395}, {'@': 1396}, {'@': 1397}, {'@': 1398}, {'@': 1399}, {'@': 1400}, {'@': 1401}, {'@': 1402}, {'@': 1403}, {'@': 1404}, {'@': 1405}, {'@': 1406}, {'@': 1407}, {'@': 1408}, {'@': 1409}, {'@': 1410}, {'@': 1411}, {'@': 1412}, {'@': 1413}, {'@': 1414}, {'@': 1415}, {'@': 1416}, {'@': 1417}, {'@': 1418}, {'@': 1419}, {'@': 1420}, {'@': 1421}, {'@': 1422}, {'@': 1423}, {'@': 1424}, {'@': 1425}, {'@': 1426}, {'@': 1427}, {'@': 1428}, {'@': 1429}, {'@': 1430}, {'@': 1431}, {'@': 1432}, {'@': 1433}, {'@': 1434}, {'@': 1435}, {'@': 1436}, {'@': 1437}, {'@': 1438}, {'@': 1439}, {'@': 1440}, {'@': 1441}, {'@': 1442}, {'@': 1443}, {'@': 1444}, {'@': 1445}, {'@': 1446}, {'@': 1447}, {'@': 1448}, {'@': 1449}, {'@': 1450}, {'@': 1451}, {'@': 1452}, {'@': 1453}, {'@': 1454}, {'@': 1455}, {'@': 1456}, {'@': 1457}, {'@': 1458}, {'@': 1459}, {'@': 1460}, {'@': 1461}, {'@': 1462}, {'@': 1463}, {'@': 1464}, {'@': 1465}, {'@': 1466}, {'@': 1467}, {'@': 1468}, {'@': 1469}, {'@': 1470}, {'@': 1471}, {'@': 1472}, {'@': 1473}, {'@': 1474}, {'@': 1475}, {'@': 1476}, {'@': 1477}, {'@': 1478}, {'@': 1479}, {'@': 1480}, {'@': 1481}, {'@': 1482}, {'@': 1483}, {'@': 1484}, {'@': 1485}, {'@': 1486}, {'@': 1487}, {'@': 1488}, {'@': 1489}, {'@': 1490}, {'@': 1491}, {'@': 1492}, {'@': 1493}, {'@': 1494}, {'@': 1495}, {'@': 1496}, {'@': 1497}, {'@': 1498}, {'@': 1499}, {'@': 1500}, {'@': 1501}, {'@': 1502}, {'@': 1503}, {'@': 1504}, {'@': 1505}, {'@': 1506}, {'@': 1507}, {'@': 1508}, {'@': 1509}, {'@': 1510}, {'@': 1511}, {'@': 1512}, {'@': 1513}, {'@': 1514}, {'@': 1515}, {'@': 1516}, {'@': 1517}, {'@': 1518}, {'@': 1519}, {'@': 1520}, {'@': 1521}, {'@': 1522}, {'@': 1523}, {'@': 1524}, {'@': 1525}, {'@': 1526}, {'@': 1527}, {'@': 1528}, {'@': 1529}, {'@': 1530}, {'@': 1531}, {'@': 1532}, {'@': 1533}, {'@': 1534}, {'@': 1535}, {'@': 1536}, {'@': 1537}, {'@': 1538}, {'@': 1539}, {'@': 1540}, {'@': 1541}, {'@': 1542}, {'@': 1543}, {'@': 1544}, {'@': 1545}, {'@': 1546}, {'@': 1547}, {'@': 1548}, {'@': 1549}, {'@': 1550}, {'@': 1551}, {'@': 1552}, {'@': 1553}, {'@': 1554}, {'@': 1555}, {'@': 1556}, {'@': 1557}, {'@': 1558}, {'@': 1559}, {'@': 1560}, {'@': 1561}, {'@': 1562}, {'@': 1563}, {'@': 1564}, {'@': 1565}, {'@': 1566}, {'@': 1567}, {'@': 1568}, {'@': 1569}, {'@': 1570}, {'@': 1571}, {'@': 1572}, {'@': 1573}, {'@': 1574}, {'@': 1575}, {'@': 1576}, {'@': 1577}, {'@': 1578}, {'@': 1579}, {'@': 1580}, {'@': 1581}, {'@': 1582}, {'@': 1583}, {'@': 1584}, {'@': 1585}, {'@': 1586}, {'@': 1587}, {'@': 1588}, {'@': 1589}, {'@': 1590}, {'@': 1591}, {'@': 1592}, {'@': 1593}, {'@': 1594}, {'@': 1595}, {'@': 1596}, {'@': 1597}, {'@': 1598}, {'@': 1599}, {'@': 1600}, {'@': 1601}, {'@': 1602}, {'@': 1603}, {'@': 1604}, {'@': 1605}, {'@': 1606}, {'@': 1607}, {'@': 1608}, {'@': 1609}, {'@': 1610}, {'@': 1611}, {'@': 1612}, {'@': 1613}, {'@': 1614}, {'@': 1615}, {'@': 1616}, {'@': 1617}, {'@': 1618}, {'@': 1619}, {'@': 1620}, {'@': 1621}, {'@': 1622}, {'@': 1623}, {'@': 1624}, {'@': 1625}, {'@': 1626}, {'@': 1627}, {'@': 1628}, {'@': 1629}, {'@': 1630}, {'@': 1631}, {'@': 1632}, {'@': 1633}, {'@': 1634}, {'@': 1635}, {'@': 1636}, {'@': 1637}, {'@': 1638}, {'@': 1639}, {'@': 1640}, {'@': 1641}, {'@': 1642}, {'@': 1643}, {'@': 1644}, {'@': 1645}, {'@': 1646}, {'@': 1647}, {'@': 1648}, {'@': 1649}, {'@': 1650}, {'@': 1651}, {'@': 1652}, {'@': 1653}, {'@': 1654}, {'@': 1655}, {'@': 1656}, {'@': 1657}, {'@': 1658}, {'@': 1659}, {'@': 1660}, {'@': 1661}, {'@': 1662}, {'@': 1663}, {'@': 1664}, {'@': 1665}, {'@': 1666}, {'@': 1667}, {'@': 1668}, {'@': 1669}, {'@': 1670}, {'@': 1671}, {'@': 1672}, {'@': 1673}, {'@': 1674}, {'@': 1675}, {'@': 1676}, {'@': 1677}, {'@': 1678}, {'@': 1679}, {'@': 1680}, {'@': 1681}, {'@': 1682}, {'@': 1683}, {'@': 1684}, {'@': 1685}, {'@': 1686}, {'@': 1687}, {'@': 1688}, {'@': 1689}, {'@': 1690}, {'@': 1691}, {'@': 1692}, {'@': 1693}, {'@': 1694}, {'@': 1695}, {'@': 1696}, {'@': 1697}, {'@': 1698}, {'@': 1699}, {'@': 1700}, {'@': 1701}, {'@': 1702}, {'@': 1703}, {'@': 1704}, {'@': 1705}, {'@': 1706}, {'@': 1707}, {'@': 1708}, {'@': 1709}, {'@': 1710}, {'@': 1711}, {'@': 1712}, {'@': 1713}, {'@': 1714}, {'@': 1715}, {'@': 1716}, {'@': 1717}, {'@': 1718}, {'@': 1719}, {'@': 1720}, {'@': 1721}, {'@': 1722}, {'@': 1723}, {'@': 1724}, {'@': 1725}, {'@': 1726}, {'@': 1727}, {'@': 1728}, {'@': 1729}, {'@': 1730}, {'@': 1731}, {'@': 1732}, {'@': 1733}, {'@': 1734}, {'@': 1735}, {'@': 1736}, {'@': 1737}, {'@': 1738}, {'@': 1739}, {'@': 1740}, {'@': 1741}, {'@': 1742}, {'@': 1743}, {'@': 1744}], 'start': ['start'], 'parser_type': 'lalr', '__type__': 'ParserConf'}, 'parser': {'tokens': {0: 'DISTRIBUTE_DIRECTIVE', 1: 'DIST_SCHEDULE_CLAUSE', 2: 'SAFESYNC_CLAUSE', 3: 'TASKLOOP_DIRECTIVE', 4: 'LINEAR_CLAUSE', 5: 'TARGET_ENTER_DATA_DIRECTIVE', 6: 'ALLOCATE_CLAUSE', 7: 'NOWAIT_CLAUSE', 8: 'MESSAGE_CLAUSE', 9: 'USES_ALLOCATORS_CLAUSE', 10: 'TARGET_UPDATE_DIRECTIVE', 11: 'FILTER_CLAUSE', 12: 'PARALLEL_DIRECTIVE', 13: 'SIMD_DIRECTIVE', 14: 'SECTIONS_DIRECTIVE', 15: 'SAFELEN_CLAUSE', 16: 'FOR_DIRECTIVE', 17: 'COPYPRIVATE_CLAUSE', 18: 'UNTIED_CLAUSE', 19: 'TARGET_DATA_DIRECTIVE', 20: 'LOOP_DIRECTIVE', 21: 'TRANSPARENT_CLAUSE', 22: 'DEPEND_CLAUSE', 23: 'USE_DEVICE_ADDR_CLAUSE', 24: 'TARGET_EXIT_DATA_DIRECTIVE', 25: 'USE_DEVICE_PTR_CLAUSE', 26: 'ORDER_CLAUSE', 27: 'LASTPRIVATE_CLAUSE', 28: 'FIRSTPRIVATE_CLAUSE', 29: 'NONTEMPORAL_CLAUSE', 30: 'SIMDLEN_CLAUSE', 31: 'DEFAULTMAP_CLAUSE', 32: 'SINGLE_DIRECTIVE', 33: 'DEFAULT_CLAUSE', 34: 'REPLAYABLE_CLAUSE', 35: 'TASK_DIRECTIVE', 36: 'DEVICE_TYPE_CLAUSE', 37: 'REDUCTION_CLAUSE', 38: 'COLLAPSE_CLAUSE', 39: 'WORKSHARE_DIRECTIVE', 40: 'MERGEABLE_CLAUSE', 41: 'NOGROUP_CLAUSE', 42: 'MASKED_DIRECTIVE', 43: 'NUM_TASKS_CLAUSE', 44: 'SHARED_CLAUSE', 45: 'INDUCTION_CLAUSE', 46: 'TARGET_DIRECTIVE', 47: 'ORDERED_CLAUSE', 48: 'HAS_DEVICE_ADDR_CLAUSE', 49: 'DEVICE_CLAUSE', 50: 'SCHEDULE_CLAUSE', 51: 'BIND_CLAUSE', 52: 'SEVERITY_CLAUSE', 53: 'IF_CLAUSE', 54: 'FINAL_CLAUSE', 55: 'PROC_BIND_CLAUSE', 56: 'WORKDISTRIBUTE_DIRECTIVE', 57: '$END', 58: 'THREAD_LIMIT_CLAUSE', 59: 'MAP_CLAUSE', 60: 'RPAR', 61: 'PRIVATE_CLAUSE', 62: 'AFFINITY_CLAUSE', 63: 'NUM_THREADS_CLAUSE', 64: 'THREADSET_CLAUSE', 65: 'TEAMS_DIRECTIVE', 66: 'NUM_TEAMS_CLAUSE', 67: 'ALIGNED_CLAUSE', 68: 'TO_CLAUSE', 69: 'PRIORITY_CLAUSE', 70: 'FROM_CLAUSE', 71: 'COPYIN_CLAUSE', 72: 'IS_DEVICE_PTR_CLAUSE', 73: 'DETACH_CLAUSE', 74: 'GRAINSIZE_CLAUSE', 75: 'IN_REDUCTION_CLAUSE', 76: 'py_stmt', 77: 'DECLARE_VARIANT_DIRECTIVE', 78: 'FLUSH_DIRECTIVE', 79: 'DECLARE_MAPPER_DIRECTIVE', 80: 'py_code_out', 81: '__py_code_out_plus_30', 82: 'TILE_DIRECTIVE', 83: 'THREADPRIVATE_DIRECTIVE', 84: 'DECLARE_SIMD_DIRECTIVE', 85: 'INTEROP_DIRECTIVE', 86: 'directive_name', 87: 'STRIPE_DIRECTIVE', 88: 'TASK_ITERATION_DIRECTIVE', 89: 'LSQB', 90: 'INTERCHANGE_DIRECTIVE', 91: 'BARRIER_DIRECTIVE', 92: 'ORDERED_DIRECTIVE', 93: 'DISPATCH_DIRECTIVE', 94: 'SCOPE_DIRECTIVE', 95: 'METADIRECTIVE_DIRECTIVE', 96: 'NOTHING_DIRECTIVE', 97: 'PY_CODE_OUT', 98: 'DECLARE_REDUCTION_DIRECTIVE', 99: 'GROUPPRIVATE_DIRECTIVE', 100: 'CANCELLATION_POINT_DIRECTIVE', 101: 'context_selector', 102: 'SCAN_DIRECTIVE', 103: 'FUSE_DIRECTIVE', 104: '_when_modifier_list', 105: 'ASSUME_DIRECTIVE', 106: 'SPLIT_DIRECTIVE', 107: 'LBRACE', 108: 'SECTION_DIRECTIVE', 109: 'TASKGROUP_DIRECTIVE', 110: 'ALLOCATE_DIRECTIVE', 111: 'ATOMIC_DIRECTIVE', 112: 'LPAR', 113: 'ERROR_DIRECTIVE', 114: 'UNROLL_DIRECTIVE', 115: 'DECLARE_TARGET_DIRECTIVE', 116: 'TASKYIELD_DIRECTIVE', 117: 'TASKWAIT_DIRECTIVE', 118: 'CANCEL_DIRECTIVE', 119: 'REQUIRES_DIRECTIVE', 120: 'DECLARE_INDUCTION_DIRECTIVE', 121: 'stmt_list', 122: 'TASKGRAPH_DIRECTIVE', 123: 'DEPOBJ_DIRECTIVE', 124: 'CRITICAL_DIRECTIVE', 125: 'GRAPH_RESET_CLAUSE', 126: 'COMMA', 127: 'GRAPH_ID_CLAUSE', 128: 'self_maps_clause', 129: 'REVERSE_OFFLOAD_CLAUSE', 130: 'SELF_MAPS_CLAUSE', 131: 'reverse_offload_clause', 132: 'UNIFIED_SHARED_MEMORY_CLAUSE', 133: 'UNIFIED_ADDRESS_CLAUSE', 134: 'ATOMIC_DEFAULT_MEM_ORDER_CLAUSE', 135: '___requires_directive_clause_list_star_12', 136: 'atomic_default_mem_order_clause', 137: 'unified_address_clause', 138: 'dynamic_allocators_clause', 139: 'DYNAMIC_ALLOCATORS_CLAUSE', 140: '_requires_directive_clause', 141: 'DEVICE_SAFESYNC_CLAUSE', 142: 'device_safesync_clause', 143: 'unified_shared_memory_clause', 144: 'IDENTIFIER', 145: 'var_list', 146: 'COLON', 147: 'ACQUIRE_CLAUSE', 148: 'SEQ_CST_CLAUSE', 149: 'WRITE_CLAUSE', 150: 'HINT_CLAUSE', 151: 'MEMSCOPE_CLAUSE', 152: 'CAPTURE_CLAUSE', 153: 'ACQ_REL_CLAUSE', 154: 'COMPARE_CLAUSE', 155: 'FAIL_CLAUSE', 156: 'RELAXED_CLAUSE', 157: 'UPDATE_CLAUSE', 158: 'WEAK_CLAUSE', 159: 'RELEASE_CLAUSE', 160: 'READ_CLAUSE', 161: 'linear_clause', 162: 'simdlen_clause', 163: 'order_clause', 164: 'private_clause', 165: 'reduction_clause', 166: 'aligned_clause', 167: 'collapse_clause', 168: 'induction_clause', 169: 'lastprivate_clause', 170: 'safelen_clause', 171: '_simd_clause', 172: 'if_clause', 173: 'nontemporal_clause', 174: 'INIT_CLAUSE', 175: 'DESTROY_CLAUSE', 176: 'USE_CLAUSE', 177: 'INTEROP_CLAUSE', 178: 'NOVARIANTS_CLAUSE', 179: 'NOCONTEXT_CLAUSE', 180: 'nowait_clause', 181: '___single_clause_list_star_16', 182: 'copyprivate_clause', 183: 'firstprivate_clause', 184: '_single_clause', 185: 'allocate_clause', 186: 'acquire_clause', 187: 'seq_cst_clause', 188: 'acq_rel_clause', 189: 'relaxed_clause', 190: 'release_clause', 191: 'memscope_clause', 192: 'apply_clause', 193: 'APPLY_CLAUSE', 194: 'py_expr', 195: '_single_clause_list', 196: '_requires_directive_clause_list', 197: 'device_type_clause', 198: 'device_clause', 199: '_target_data_clause', 200: 'priority_clause', 201: 'nogroup_clause', 202: 'use_device_ptr_clause', 203: 'use_device_addr_clause', 204: 'default_clause', 205: 'affinity_clause', 206: 'depend_clause', 207: 'transparent_clause', 208: 'in_reduction_clause', 209: '_target_data_clause_list', 210: 'shared_clause', 211: 'mergeable_clause', 212: 'map_clause', 213: 'detach_clause', 214: '_for_clause', 215: 'ordered_clause', 216: '_for_clause_list', 217: 'schedule_clause', 218: '_simd_clause_list', 219: '_construct_type_clause', 220: 'ENTER_CLAUSE', 221: 'LINK_CLAUSE', 222: 'INDIRECT_CLAUSE', 223: 'LOCAL_CLAUSE', 224: '_declare_target_clause_list', 225: '_declare_target_clause', 226: 'local_clause', 227: 'indirect_clause', 228: 'enter_clause', 229: 'link_clause', 230: 'NO_OPENMP_CONSTRUCTS_CLAUSE', 231: 'NO_OPENMP_CLAUSE', 232: '_assume_clause', 233: '_assume_clause_list', 234: 'ABSENT_CLAUSE', 235: 'NO_PARALLELISM_CLAUSE', 236: 'absent_clause', 237: 'no_openmp_clause', 238: 'no_openmp_constructs_clause', 239: 'holds_clause', 240: 'NO_OPENMP_ROUTINES_CLAUSE', 241: 'CONTAINS_CLAUSE', 242: 'contains_clause', 243: 'HOLDS_CLAUSE', 244: 'no_parallelism_clause', 245: 'no_openmp_routines_clause', 246: 'graph_id_clause', 247: 'graph_reset_clause', 248: '_taskgraph_clause', 249: '_taskgraph_clause_list', 250: 'use_clause', 251: '_interop_clause', 252: '_interop_clause_list', 253: 'destroy_clause', 254: 'init_clause', 255: 'ITERATOR', 256: 'iterator_modifier', 257: '_affinity_modifier_list', 258: '__combined_directive_plus_0', 259: '_combined_directive_name', 260: 'FULL_CLAUSE', 261: 'full_clause', 262: 'partial_clause', 263: 'PARTIAL_CLAUSE', 264: '_unroll_clause_list', 265: 'uniform_clause', 266: 'NOTINBRANCH', 267: '_declare_simd_clause', 268: 'UNIFORM_CLAUSE', 269: 'notinbranch_clause', 270: 'INBRANCH', 271: '_declare_simd_clause_list', 272: 'inbranch_clause', 273: 'init_complete_clause', 274: 'INCLUSIVE_CLAUSE', 275: 'INIT_COMPLETE_CLAUSE', 276: '_scan_clauses', 277: 'EXCLUSIVE_CLAUSE', 278: 'exclusive_clause', 279: 'inclusive_clause', 280: 'threadset_clause', 281: 'num_tasks_clause', 282: '_taskloop_clause', 283: 'untied_clause', 284: 'grainsize_clause', 285: '_taskloop_clause_list', 286: 'final_clause', 287: 'replayable_clause', 288: 'at_clause', 289: '_error_clause', 290: 'severity_clause', 291: '_error_clause_list', 292: 'message_clause', 293: 'AT_CLAUSE', 294: '_teams_clause', 295: 'num_teams_clause', 296: 'thread_limit_clause', 297: '_teams_clause_list', 298: 'permutation_clause', 299: 'PERMUTATION_CLAUSE', 300: '_interchange_clause_list', 301: '_scope_clause', 302: '_scope_clause_list', 303: 'directive_list', 304: '_metadirective_clause_list', 305: 'when_clause', 306: 'WHEN_CLAUSE', 307: '_distribute_clause_list', 308: '_distribute_clause', 309: 'dist_schedule_clause', 310: 'induction_modifier_name', 311: 'STRICT', 312: 'step_modifier', 313: 'STEP', 314: 'RELAXED', 315: 'cancellation_point_directive', 316: 'declare_target_directive', 317: 'scan_directive', 318: 'flush_directive', 319: 'declare_reduction_directive6', 320: 'taskwait_directive', 321: 'section_directive', 322: 'target_enter_data_directive', 323: 'metadirective_directive', 324: 'declare_simd_directive', 325: 'nothing_directive', 326: 'declare_variant_directive', 327: 'target_update_directive', 328: 'requires_directive', 329: 'interop_directive', 330: 'ordered_directive', 331: 'critical_directive', 332: 'combined_directive', 333: 'workshare_directive', 334: 'taskgroup_directive', 335: 'target_exit_data_directive', 336: 'sections_directive', 337: 'workdistribute_directive', 338: 'taskyield_directive', 339: 'target_data_directive', 340: 'declare_induction_directive', 341: 'depobj_directive', 342: 'masked_directive', 343: 'start', 344: 'scope_directive', 345: 'barrier_directive', 346: 'parallel_directive', 347: 'target_directive', 348: 'for_directive', 349: 'distribute_directive', 350: 'dispatch_directive', 351: 'tile_directive', 352: 'task_directive', 353: 'threadprivate_directive', 354: 'taskgraph_directive', 355: 'taskloop_directive', 356: 'cancel_directive', 357: 'declare_mapper_directive', 358: 'interchange_directive', 359: 'simd_directive', 360: 'fuse_directive', 361: 'assume_directive', 362: 'atomic_directive', 363: 'split_directive', 364: 'teams_directive', 365: 'error_directive', 366: 'single_directive', 367: 'declare_reduction_directive', 368: 'task_iteration_directive', 369: 'stripe_directive', 370: 'unroll_directive', 371: 'allocate_directive', 372: 'loop_directive', 373: 'groupprivate_directive', 374: 'OTHERWISE_CLAUSE', 375: 'otherwise_clause', 376: 'mapper_modifier', 377: '_from_modifier', 378: '_from_modifier_list', 379: 'PRESENT', 380: 'MAPPER', 381: 'present_name', 382: 'AUTOMAP', 383: 'automap_name', 384: '_aligned_modifier_list', 385: 'alignment_modifier', 386: 'INTEGER', 387: 'THREADS_CLAUSE', 388: 'threads_clause', 389: '_to_modifier_list', 390: 'novariants_clause', 391: 'interop_clause', 392: 'has_device_addr_clause', 393: '_dispatch_clause', 394: 'nocontext_clause', 395: 'is_device_ptr_clause', 396: 'uses_allocators_clause', 397: '_target_clause', 398: 'defaultmap_clause', 399: 'py_type', 400: 'SIZES_CLAUSE', 401: 'sizes_clause', 402: '_target_exit_data_clause', 403: 'ACQUIRE', 404: 'fail_clause_arg', 405: 'SEQ_CST', 406: '_target_enter_data_clause', 407: 'conditional_name', 408: '_lastprivate_modifier_list', 409: 'CONDITIONAL', 410: 'bind_clause', 411: '_loop_clause', 412: 'hint_clause', 413: 'capture_clause', 414: 'read_clause', 415: 'write_clause', 416: 'compare_clause', 417: 'fail_clause', 418: '_atomic_clause', 419: 'weak_clause', 420: 'atomic_update_clause', 421: '_taskwait_clause', 422: 'THREAD', 423: 'bind_clause_arg', 424: 'TEAMS', 425: 'PARALLEL', 426: '_sections_clause', 427: 'preference_specification', 428: 'expr_list', 429: 'PREFER_TYPE', 430: '_init_modifier', 431: 'TARGET', 432: 'IN', 433: 'interop_type_modifier_name', 434: 'MUTEXINOUTSET', 435: 'TARGETSYNC', 436: 'INOUT', 437: 'depinfo_modifier', 438: 'OUT', 439: 'INOUTSET', 440: 'prefer_type_modifier', 441: 'RBRACE', 442: 'PY_CODE_IN', 443: 'RSQB', 444: 'from_clause', 445: 'to_clause', 446: '_target_update_clause', 447: '_task_iteration_clause', 448: 'strict_name', 449: '_num_threads_modifier_list', 450: '__py_code_in_plus_31', 451: 'py_code_in', 452: 'COUNTS_CLAUSE', 453: 'counts_clause', 454: 'PLUS', 455: 'BITWISE_AND', 456: 'LOGIC_OR', 457: 'BITWISE_OR', 458: 'MIN', 459: 'BITWISE_XOR', 460: 'reduction_op', 461: 'LOGIC_AND', 462: 'MULT', 463: 'MAX', 464: 'OMP_POOL', 465: 'OMP_TEAM', 466: 'threadset_clause_arg', 467: '___for_clause_list_star_18', 468: '___metadirective_clause_list_star_4', 469: 'TASK_REDUCTION_CLAUSE', 470: 'SIMD_CLAUSE', 471: 'simd_clause', 472: 'PRIMARY', 473: 'proc_bind_clause_arg', 474: 'CLOSE', 475: 'SPREAD', 476: '_task_clause', 477: '_taskgroup_clause', 478: 'task_reduction_clause', 479: 'safesync_clause', 480: '_parallel_clause', 481: 'proc_bind_clause', 482: 'num_threads_clause', 483: 'copyin_clause', 484: 'filter_clause', 485: '_combined_clause', 486: 'lower_bound', 487: 'FATAL', 488: 'severity_clause_arg', 489: 'WARNING', 490: 'TASK', 491: '_reduction_modifier', 492: 'reduction_modifier_name', 493: 'INSCAN', 494: 'ORIGINAL', 495: 'DEFAULT', 496: 'original_modifier', 497: 'type_list', 498: '__preference_specification_star_38', 499: '__directive_list_star_14', 500: 'ALLOCATOR_CLAUSE', 501: 'ALIGN_CLAUSE', 502: '___to_modifier_list_star_22', 503: 'attr_selector', 504: 'fr_selector', 505: 'ATTR', 506: 'FR', 507: 'TRAITS', 508: 'memspace_modifier', 509: '_uses_allocator_modifier', 510: 'traits_modifier', 511: 'MEMSPACE', 512: '_declare_variant_clause', 513: 'match_clause', 514: 'APPEND_ARGS_CLAUSE', 515: 'ADJUST_ARGS_CLAUSE', 516: 'append_args_clause', 517: 'MATCH_CLAUSE', 518: '_declare_variant_clause_list', 519: 'adjust_args_clause', 520: 'depobj_update_clause', 521: '__prefer_type_modifier_star_37', 522: 'COLLECTOR_CLAUSE', 523: 'collector_clause', 524: 'COMBINER_CLAUSE', 525: 'combiner_clause', 526: '__declare_mapper_directive_plus_2', 527: 'align_clause', 528: 'allocator_clause', 529: '_allocate_clause', 530: 'variable_category_name', 531: 'ALL', 532: 'ALLOCATABLE', 533: 'POINTER', 534: 'AGGREGATE', 535: 'SCALAR', 536: 'INDUCTOR_CLAUSE', 537: 'inductor_clause', 538: 'initializer_clause', 539: 'INITIALIZER_CLAUSE', 540: 'memscope_clause_arg', 541: 'CGROUP', 542: 'DEVICE', 543: '__append_args_arg_star_6', 544: 'SAVED', 545: 'saved_name', 546: '_allocate_modifier', 547: 'ALIGN', 548: 'allocator_modifier', 549: 'ALLOCATOR', 550: 'align_modifier', 551: '_apply_directive', 552: 'REVERSE_DIRECTIVE', 553: 'apply_clause_arg', 554: 'atomic_default_mem_order_clause_arg', 555: 'ACQ_REL', 556: 'device_type_kind', 557: 'ANY', 558: 'NOHOST', 559: 'HOST', 560: 'iterator_specifier', 561: '___declare_target_clause_list_star_11', 562: 'DEPOBJ', 563: 'task_dependence_name', 564: '_depend_modifier', 565: '_default_modifier', 566: '___assume_clause_list_star_13', 567: 'DEVICE_NUM', 568: 'ANCESTOR', 569: 'device_modifier_name', 570: 'ref_modifier_name', 571: 'REF_PTR', 572: 'ALWAYS', 573: 'SELF', 574: 'DELETE', 575: 'REF_PTR_PTEE', 576: '_map_modifier', 577: 'REF_PTEE', 578: 'present_modifier_name', 579: 'close_modifier_name', 580: 'delete_modifier_name', 581: 'always_modifier_name', 582: 'self_modifier_name', 583: '_defaultmap_modifier_list', 584: 'STORAGE', 585: 'map_type_name', 586: 'TO', 587: 'TOFROM', 588: 'FROM', 589: 'combined_clause_list', 590: 'CONCURRENT', 591: 'VAL', 592: 'linear_modifier_name', 593: 'step_simple_modifier', 594: '_linear_modifier', 595: 'UVAL', 596: 'REF', 597: '_linear_modifier_list', 598: 'order_modifier_name', 599: 'UNCONSTRAINED', 600: 'REPRODUCIBLE', 601: 'ordering_modifier_name', 602: 'NONMONOTONIC', 603: 'SIMD', 604: 'MONOTONIC', 605: 'chunk_modifier_name', 606: '_schedule_modifier', 607: 'induction_op', 608: 'AUTO', 609: 'GUIDED', 610: 'schedule_type', 611: 'STATIC', 612: 'RUNTIME', 613: 'DYNAMIC', 614: 'allocator_simple_modifier', 615: '_allocate_modifier_list', 616: '_schedule_modifier_list', 617: '___declare_simd_clause_list_star_9', 618: 'PRIVATE', 619: 'SHARED', 620: 'INTEROP', 621: 'append_args_arg', 622: 'append_op', 623: '_declare_reduction_clause_list', 624: '_ordered_clause_list', 625: 'DOACROSS_CLAUSE', 626: 'doacross_clause', 627: '_depobj_update_modifier_list', 628: '_dispatch_clause_list', 629: '_target_clause_list', 630: '_target_exit_data_clause_list', 631: '___allocate_modifier_list_star_28', 632: '_taskwait_clause_list', 633: '_sections_clause_list', 634: '_target_enter_data_clause_list', 635: '_loop_clause_list', 636: '__apply_clause_arg_star_25', 637: 'LOOPRANGE_CLAUSE', 638: 'looprange_clause', 639: '_split_clause_list', 640: '_taskgroup_clause_list', 641: 'SOURCE', 642: 'SINK', 643: 'dependence_type_name', 644: '__expr_list_star_33', 645: '___depend_modifier_list_star_26', 646: '___map_modifier_list_star_29', 647: 'EQUAL', 648: '__iterator_modifier_star_36', 649: '___linear_modifier_list_star_10', 650: '_atomic_clause_list', 651: '___atomic_clause_list_star_24', 652: '_target_update_clause_list', 653: '_tile_clause_list', 654: '___sections_clause_list_star_17', 655: '_task_iteration_clause_list', 656: '_task_clause_list', 657: '_parallel_clause_list', 658: '_stripe_clause_list', 659: '_induction_modifier_list', 660: 'interop_type', 661: 'NEED_DEVICE_ADDR', 662: 'NEED_DEVICE_PTR', 663: 'NOTHING', 664: 'adjust_op_name', 665: '___dispatch_clause_list_star_8', 666: '___task_clause_list_star_20', 667: '__append_op_star_7', 668: 'at_clause_arg', 669: 'EXECUTION', 670: 'COMPILATION', 671: '_declare_induction_clause_list', 672: '___declare_variant_clause_list_star_5', 673: '_adjust_args_modifier_list', 674: '__type_list_star_34', 675: '__stmt_list_star_35', 676: '___uses_allocator_modifier_list_star_21', 677: '_enter_modifier_list', 678: '___parallel_clause_list_star_15', 679: '___schedule_modifier_list_star_19', 680: '_init_modifier_list', 681: '___allocate_clause_list_star_3', 682: '__var_list_star_32', 683: '___reduction_modifier_list_star_27', 684: '_num_tasks_modifier_list', 685: 'FIRSTPRIVATE', 686: '_defaultmap_arg', 687: 'NONE', 688: '_firstprivate_modifier', 689: '_uses_allocator_modifier_list', 690: 'OFFSETS', 691: 'IDENTITY', 692: 'UNROLLED', 693: 'SPLIT', 694: 'INTRATILE', 695: 'FUSED', 696: 'REVERSED', 697: 'INTERCHANGED', 698: 'GRID', 699: '_apply_modifier_list', 700: 'loop_modifier', 701: '_allocate_clause_list', 702: '_doacross_modifier_list', 703: '_grainsize_modifier_list', 704: '_depend_modifier_list', 705: '__combined_clause_list_star_1', 706: '_device_modifier_list', 707: '_map_modifier_list', 708: '___init_modifier_list_star_23', 709: '_order_modifier_list', 710: '_reduction_modifier_list', 711: '_num_teams_modifier_list'}, 'states': {0: {0: (1, {'@': 430}), 1: (1, {'@': 430}), 2: (1, {'@': 430}), 3: (1, {'@': 430}), 4: (1, {'@': 430}), 5: (1, {'@': 430}), 6: (1, {'@': 430}), 7: (1, {'@': 430}), 8: (1, {'@': 430}), 9: (1, {'@': 430}), 10: (1, {'@': 430}), 11: (1, {'@': 430}), 12: (1, {'@': 430}), 13: (1, {'@': 430}), 14: (1, {'@': 430}), 15: (1, {'@': 430}), 16: (1, {'@': 430}), 17: (1, {'@': 430}), 18: (1, {'@': 430}), 19: (1, {'@': 430}), 20: (1, {'@': 430}), 21: (1, {'@': 430}), 22: (1, {'@': 430}), 23: (1, {'@': 430}), 24: (1, {'@': 430}), 25: (1, {'@': 430}), 26: (1, {'@': 430}), 27: (1, {'@': 430}), 28: (1, {'@': 430}), 29: (1, {'@': 430}), 30: (1, {'@': 430}), 31: (1, {'@': 430}), 32: (1, {'@': 430}), 33: (1, {'@': 430}), 34: (1, {'@': 430}), 35: (1, {'@': 430}), 36: (1, {'@': 430}), 37: (1, {'@': 430}), 38: (1, {'@': 430}), 39: (1, {'@': 430}), 40: (1, {'@': 430}), 41: (1, {'@': 430}), 42: (1, {'@': 430}), 43: (1, {'@': 430}), 44: (1, {'@': 430}), 45: (1, {'@': 430}), 46: (1, {'@': 430}), 47: (1, {'@': 430}), 48: (1, {'@': 430}), 49: (1, {'@': 430}), 50: (1, {'@': 430}), 51: (1, {'@': 430}), 52: (1, {'@': 430}), 53: (1, {'@': 430}), 54: (1, {'@': 430}), 55: (1, {'@': 430}), 56: (1, {'@': 430}), 57: (1, {'@': 430}), 58: (1, {'@': 430}), 59: (1, {'@': 430}), 60: (1, {'@': 430}), 61: (1, {'@': 430}), 62: (1, {'@': 430}), 63: (1, {'@': 430}), 64: (1, {'@': 430}), 65: (1, {'@': 430}), 66: (1, {'@': 430}), 67: (1, {'@': 430}), 68: (1, {'@': 430}), 69: (1, {'@': 430}), 70: (1, {'@': 430}), 71: (1, {'@': 430}), 72: (1, {'@': 430}), 73: (1, {'@': 430}), 74: (1, {'@': 430}), 75: (1, {'@': 430})}, 1: {76: (0, 2146), 77: (0, 17), 78: (0, 1960), 79: (0, 1973), 80: (0, 2149), 12: (0, 396), 81: (0, 2295), 82: (0, 791), 83: (0, 809), 84: (0, 811), 85: (0, 816), 86: (0, 2150), 10: (0, 826), 87: (0, 842), 35: (0, 844), 88: (0, 848), 89: (0, 2384), 90: (0, 853), 91: (0, 863), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 56: (0, 783), 95: (0, 786), 96: (0, 789), 97: (0, 2370), 98: (0, 793), 19: (0, 800), 13: (0, 802), 32: (0, 807), 99: (0, 812), 100: (0, 817), 101: (0, 2151), 20: (0, 822), 102: (0, 823), 103: (0, 825), 104: (0, 2152), 105: (0, 830), 65: (0, 834), 106: (0, 838), 107: (0, 2409), 108: (0, 400), 109: (0, 390), 46: (0, 781), 110: (0, 799), 111: (0, 821), 14: (0, 399), 112: (0, 2376), 113: (0, 828), 114: (0, 832), 0: (0, 846), 42: (0, 858), 39: (0, 860), 115: (0, 44), 116: (0, 780), 5: (0, 787), 117: (0, 804), 24: (0, 814), 118: (0, 819), 119: (0, 836), 120: (0, 840), 121: (0, 2154), 122: (0, 850), 3: (0, 855), 123: (0, 856), 124: (0, 864)}, 2: {60: (1, {'@': 1076}), 125: (1, {'@': 1076}), 126: (1, {'@': 1076}), 53: (1, {'@': 1076}), 127: (1, {'@': 1076}), 41: (1, {'@': 1076}), 57: (1, {'@': 1076})}, 3: {128: (0, 14), 129: (0, 12), 130: (0, 11), 131: (0, 10), 132: (0, 8), 133: (0, 4), 134: (0, 13), 135: (0, 2452), 136: (0, 9), 137: (0, 5), 138: (0, 6), 139: (0, 18), 140: (0, 2457), 141: (0, 49), 126: (0, 2458), 142: (0, 46), 143: (0, 26), 57: (1, {'@': 674}), 60: (1, {'@': 674})}, 4: {112: (0, 2425), 133: (1, {'@': 696}), 130: (1, {'@': 696}), 141: (1, {'@': 696}), 60: (1, {'@': 696}), 129: (1, {'@': 696}), 126: (1, {'@': 696}), 134: (1, {'@': 696}), 57: (1, {'@': 696}), 132: (1, {'@': 696}), 139: (1, {'@': 696})}, 5: {133: (1, {'@': 680}), 130: (1, {'@': 680}), 141: (1, {'@': 680}), 60: (1, {'@': 680}), 129: (1, {'@': 680}), 126: (1, {'@': 680}), 134: (1, {'@': 680}), 57: (1, {'@': 680}), 132: (1, {'@': 680}), 139: (1, {'@': 680})}, 6: {133: (1, {'@': 677}), 130: (1, {'@': 677}), 141: (1, {'@': 677}), 60: (1, {'@': 677}), 129: (1, {'@': 677}), 126: (1, {'@': 677}), 134: (1, {'@': 677}), 57: (1, {'@': 677}), 132: (1, {'@': 677}), 139: (1, {'@': 677})}, 7: {144: (0, 2316), 145: (0, 1007)}, 8: {112: (0, 2416), 133: (1, {'@': 699}), 130: (1, {'@': 699}), 141: (1, {'@': 699}), 60: (1, {'@': 699}), 129: (1, {'@': 699}), 126: (1, {'@': 699}), 134: (1, {'@': 699}), 57: (1, {'@': 699}), 132: (1, {'@': 699}), 139: (1, {'@': 699})}, 9: {133: (1, {'@': 675}), 130: (1, {'@': 675}), 141: (1, {'@': 675}), 60: (1, {'@': 675}), 129: (1, {'@': 675}), 126: (1, {'@': 675}), 134: (1, {'@': 675}), 57: (1, {'@': 675}), 132: (1, {'@': 675}), 139: (1, {'@': 675})}, 10: {133: (1, {'@': 678}), 130: (1, {'@': 678}), 141: (1, {'@': 678}), 60: (1, {'@': 678}), 129: (1, {'@': 678}), 126: (1, {'@': 678}), 134: (1, {'@': 678}), 57: (1, {'@': 678}), 132: (1, {'@': 678}), 139: (1, {'@': 678})}, 11: {112: (0, 2411), 133: (1, {'@': 702}), 130: (1, {'@': 702}), 141: (1, {'@': 702}), 60: (1, {'@': 702}), 129: (1, {'@': 702}), 126: (1, {'@': 702}), 134: (1, {'@': 702}), 57: (1, {'@': 702}), 132: (1, {'@': 702}), 139: (1, {'@': 702})}, 12: {112: (0, 2408), 133: (1, {'@': 693}), 130: (1, {'@': 693}), 141: (1, {'@': 693}), 60: (1, {'@': 693}), 129: (1, {'@': 693}), 126: (1, {'@': 693}), 134: (1, {'@': 693}), 57: (1, {'@': 693}), 132: (1, {'@': 693}), 139: (1, {'@': 693})}, 13: {112: (0, 2427)}, 14: {133: (1, {'@': 679}), 130: (1, {'@': 679}), 141: (1, {'@': 679}), 60: (1, {'@': 679}), 129: (1, {'@': 679}), 126: (1, {'@': 679}), 134: (1, {'@': 679}), 57: (1, {'@': 679}), 132: (1, {'@': 679}), 139: (1, {'@': 679})}, 15: {112: (0, 1641)}, 16: {60: (1, {'@': 530}), 57: (1, {'@': 530})}, 17: {126: (1, {'@': 369}), 146: (1, {'@': 369}), 60: (1, {'@': 369})}, 18: {112: (0, 2437), 133: (1, {'@': 690}), 130: (1, {'@': 690}), 141: (1, {'@': 690}), 60: (1, {'@': 690}), 129: (1, {'@': 690}), 126: (1, {'@': 690}), 134: (1, {'@': 690}), 57: (1, {'@': 690}), 132: (1, {'@': 690}), 139: (1, {'@': 690})}, 19: {6: (1, {'@': 904}), 60: (1, {'@': 904}), 7: (1, {'@': 904}), 61: (1, {'@': 904}), 126: (1, {'@': 904}), 28: (1, {'@': 904}), 17: (1, {'@': 904}), 57: (1, {'@': 904})}, 20: {112: (0, 1000)}, 21: {60: (1, {'@': 900}), 57: (1, {'@': 900})}, 22: {6: (1, {'@': 906}), 60: (1, {'@': 906}), 7: (1, {'@': 906}), 61: (1, {'@': 906}), 126: (1, {'@': 906}), 28: (1, {'@': 906}), 17: (1, {'@': 906}), 57: (1, {'@': 906})}, 23: {6: (1, {'@': 905}), 60: (1, {'@': 905}), 7: (1, {'@': 905}), 61: (1, {'@': 905}), 126: (1, {'@': 905}), 28: (1, {'@': 905}), 17: (1, {'@': 905}), 57: (1, {'@': 905})}, 24: {6: (1, {'@': 908}), 60: (1, {'@': 908}), 7: (1, {'@': 908}), 61: (1, {'@': 908}), 126: (1, {'@': 908}), 28: (1, {'@': 908}), 17: (1, {'@': 908}), 57: (1, {'@': 908})}, 25: {112: (0, 83)}, 26: {133: (1, {'@': 681}), 130: (1, {'@': 681}), 141: (1, {'@': 681}), 60: (1, {'@': 681}), 129: (1, {'@': 681}), 126: (1, {'@': 681}), 134: (1, {'@': 681}), 57: (1, {'@': 681}), 132: (1, {'@': 681}), 139: (1, {'@': 681})}, 27: {6: (1, {'@': 907}), 60: (1, {'@': 907}), 7: (1, {'@': 907}), 61: (1, {'@': 907}), 126: (1, {'@': 907}), 28: (1, {'@': 907}), 17: (1, {'@': 907}), 57: (1, {'@': 907})}, 28: {112: (0, 2363), 57: (1, {'@': 1305}), 60: (1, {'@': 1305}), 147: (1, {'@': 1305}), 126: (1, {'@': 1305}), 148: (1, {'@': 1305}), 149: (1, {'@': 1305}), 150: (1, {'@': 1305}), 151: (1, {'@': 1305}), 152: (1, {'@': 1305}), 153: (1, {'@': 1305}), 154: (1, {'@': 1305}), 155: (1, {'@': 1305}), 156: (1, {'@': 1305}), 157: (1, {'@': 1305}), 158: (1, {'@': 1305}), 159: (1, {'@': 1305}), 160: (1, {'@': 1305})}, 29: {112: (0, 1834), 60: (1, {'@': 1322}), 57: (1, {'@': 1322})}, 30: {112: (0, 2337), 60: (1, {'@': 1320}), 57: (1, {'@': 1320})}, 31: {60: (1, {'@': 672}), 57: (1, {'@': 672})}, 32: {112: (0, 2308), 60: (1, {'@': 1324}), 57: (1, {'@': 1324})}, 33: {112: (0, 2379)}, 34: {112: (0, 2333), 60: (1, {'@': 1316}), 57: (1, {'@': 1316})}, 35: {161: (0, 1867), 53: (0, 387), 4: (0, 405), 29: (0, 1870), 162: (0, 1874), 163: (0, 1879), 27: (0, 408), 164: (0, 1881), 26: (0, 1797), 38: (0, 1811), 165: (0, 1888), 166: (0, 1893), 167: (0, 1898), 168: (0, 1903), 61: (0, 25), 15: (0, 1909), 67: (0, 1913), 169: (0, 1917), 126: (0, 2212), 37: (0, 1828), 45: (0, 1833), 30: (0, 1920), 170: (0, 1924), 171: (0, 2219), 172: (0, 1929), 173: (0, 1933), 57: (1, {'@': 871}), 60: (1, {'@': 871})}, 36: {60: (1, {'@': 517}), 57: (1, {'@': 517})}, 37: {112: (0, 2346), 60: (1, {'@': 1326}), 57: (1, {'@': 1326})}, 38: {144: (0, 2316), 145: (0, 2344)}, 39: {112: (0, 2329)}, 40: {112: (0, 1963), 60: (1, {'@': 1318}), 57: (1, {'@': 1318})}, 41: {112: (0, 1457), 57: (1, {'@': 1302}), 60: (1, {'@': 1302}), 147: (1, {'@': 1302}), 126: (1, {'@': 1302}), 148: (1, {'@': 1302}), 149: (1, {'@': 1302}), 150: (1, {'@': 1302}), 151: (1, {'@': 1302}), 152: (1, {'@': 1302}), 153: (1, {'@': 1302}), 154: (1, {'@': 1302}), 155: (1, {'@': 1302}), 156: (1, {'@': 1302}), 157: (1, {'@': 1302}), 158: (1, {'@': 1302}), 159: (1, {'@': 1302}), 160: (1, {'@': 1302})}, 42: {112: (0, 1557), 57: (1, {'@': 1311}), 60: (1, {'@': 1311}), 147: (1, {'@': 1311}), 126: (1, {'@': 1311}), 148: (1, {'@': 1311}), 149: (1, {'@': 1311}), 150: (1, {'@': 1311}), 151: (1, {'@': 1311}), 152: (1, {'@': 1311}), 153: (1, {'@': 1311}), 154: (1, {'@': 1311}), 155: (1, {'@': 1311}), 156: (1, {'@': 1311}), 157: (1, {'@': 1311}), 158: (1, {'@': 1311}), 159: (1, {'@': 1311}), 160: (1, {'@': 1311})}, 43: {112: (0, 1508), 57: (1, {'@': 1308}), 60: (1, {'@': 1308}), 147: (1, {'@': 1308}), 126: (1, {'@': 1308}), 148: (1, {'@': 1308}), 149: (1, {'@': 1308}), 150: (1, {'@': 1308}), 151: (1, {'@': 1308}), 152: (1, {'@': 1308}), 153: (1, {'@': 1308}), 154: (1, {'@': 1308}), 155: (1, {'@': 1308}), 156: (1, {'@': 1308}), 157: (1, {'@': 1308}), 158: (1, {'@': 1308}), 159: (1, {'@': 1308}), 160: (1, {'@': 1308})}, 44: {126: (1, {'@': 372}), 146: (1, {'@': 372}), 60: (1, {'@': 372})}, 45: {112: (0, 2357), 6: (1, {'@': 1479}), 60: (1, {'@': 1479}), 7: (1, {'@': 1479}), 61: (1, {'@': 1479}), 126: (1, {'@': 1479}), 28: (1, {'@': 1479}), 17: (1, {'@': 1479}), 57: (1, {'@': 1479}), 59: (1, {'@': 1479}), 21: (1, {'@': 1479}), 22: (1, {'@': 1479}), 44: (1, {'@': 1479}), 62: (1, {'@': 1479}), 23: (1, {'@': 1479}), 25: (1, {'@': 1479}), 49: (1, {'@': 1479}), 33: (1, {'@': 1479}), 53: (1, {'@': 1479}), 69: (1, {'@': 1479}), 40: (1, {'@': 1479}), 41: (1, {'@': 1479}), 75: (1, {'@': 1479}), 73: (1, {'@': 1479}), 45: (1, {'@': 1479}), 37: (1, {'@': 1479}), 38: (1, {'@': 1479}), 47: (1, {'@': 1479}), 26: (1, {'@': 1479}), 27: (1, {'@': 1479}), 4: (1, {'@': 1479}), 50: (1, {'@': 1479}), 174: (1, {'@': 1479}), 175: (1, {'@': 1479}), 176: (1, {'@': 1479}), 177: (1, {'@': 1479}), 48: (1, {'@': 1479}), 72: (1, {'@': 1479}), 178: (1, {'@': 1479}), 179: (1, {'@': 1479}), 43: (1, {'@': 1479}), 1: (1, {'@': 1479}), 2: (1, {'@': 1479}), 51: (1, {'@': 1479}), 52: (1, {'@': 1479}), 8: (1, {'@': 1479}), 9: (1, {'@': 1479}), 11: (1, {'@': 1479}), 54: (1, {'@': 1479}), 55: (1, {'@': 1479}), 15: (1, {'@': 1479}), 18: (1, {'@': 1479}), 58: (1, {'@': 1479}), 63: (1, {'@': 1479}), 29: (1, {'@': 1479}), 30: (1, {'@': 1479}), 31: (1, {'@': 1479}), 64: (1, {'@': 1479}), 66: (1, {'@': 1479}), 67: (1, {'@': 1479}), 34: (1, {'@': 1479}), 36: (1, {'@': 1479}), 68: (1, {'@': 1479}), 70: (1, {'@': 1479}), 71: (1, {'@': 1479}), 74: (1, {'@': 1479})}, 46: {133: (1, {'@': 676}), 130: (1, {'@': 676}), 141: (1, {'@': 676}), 60: (1, {'@': 676}), 129: (1, {'@': 676}), 126: (1, {'@': 676}), 134: (1, {'@': 676}), 57: (1, {'@': 676}), 132: (1, {'@': 676}), 139: (1, {'@': 676})}, 47: {60: (1, {'@': 736}), 57: (1, {'@': 736})}, 48: {112: (0, 1561), 57: (1, {'@': 1314}), 60: (1, {'@': 1314}), 147: (1, {'@': 1314}), 126: (1, {'@': 1314}), 148: (1, {'@': 1314}), 149: (1, {'@': 1314}), 150: (1, {'@': 1314}), 151: (1, {'@': 1314}), 152: (1, {'@': 1314}), 153: (1, {'@': 1314}), 154: (1, {'@': 1314}), 155: (1, {'@': 1314}), 156: (1, {'@': 1314}), 157: (1, {'@': 1314}), 158: (1, {'@': 1314}), 159: (1, {'@': 1314}), 160: (1, {'@': 1314})}, 49: {112: (0, 1658), 133: (1, {'@': 705}), 130: (1, {'@': 705}), 141: (1, {'@': 705}), 60: (1, {'@': 705}), 129: (1, {'@': 705}), 126: (1, {'@': 705}), 134: (1, {'@': 705}), 57: (1, {'@': 705}), 132: (1, {'@': 705}), 139: (1, {'@': 705})}, 50: {112: (0, 2318)}, 51: {17: (0, 50), 7: (0, 45), 126: (0, 2394), 28: (0, 33), 180: (0, 27), 181: (0, 2396), 61: (0, 25), 164: (0, 24), 182: (0, 23), 183: (0, 22), 6: (0, 20), 184: (0, 2402), 185: (0, 19), 57: (1, {'@': 903}), 60: (1, {'@': 903})}, 52: {156: (0, 43), 159: (0, 42), 153: (0, 41), 148: (0, 48), 186: (0, 40), 151: (0, 39), 112: (0, 38), 187: (0, 32), 188: (0, 34), 189: (0, 30), 190: (0, 29), 191: (0, 37), 147: (0, 28), 60: (1, {'@': 1328}), 57: (1, {'@': 1328})}, 53: {112: (0, 2390)}, 54: {144: (0, 2316), 145: (0, 2105)}, 55: {192: (0, 2325), 193: (0, 53)}, 56: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 194: (0, 2051), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 86: (0, 2046), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 57: {60: (0, 2592)}, 58: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 86: (0, 2047), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 194: (0, 2085), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 59: {115: (0, 44), 77: (0, 17), 108: (0, 400), 194: (0, 2035), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 86: (0, 2003), 124: (0, 864)}, 60: {144: (0, 2316), 115: (0, 44), 77: (0, 17), 108: (0, 400), 145: (0, 2036), 109: (0, 390), 86: (0, 2026), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 61: {17: (0, 50), 7: (0, 45), 184: (0, 51), 28: (0, 33), 180: (0, 27), 61: (0, 25), 164: (0, 24), 182: (0, 23), 183: (0, 22), 195: (0, 21), 6: (0, 20), 185: (0, 19), 0: (1, {'@': 423}), 3: (1, {'@': 423}), 20: (1, {'@': 423}), 32: (1, {'@': 423}), 65: (1, {'@': 423}), 10: (1, {'@': 423}), 35: (1, {'@': 423}), 12: (1, {'@': 423}), 46: (1, {'@': 423}), 24: (1, {'@': 423}), 14: (1, {'@': 423}), 13: (1, {'@': 423}), 39: (1, {'@': 423}), 42: (1, {'@': 423}), 56: (1, {'@': 423}), 16: (1, {'@': 423}), 5: (1, {'@': 423}), 19: (1, {'@': 423}), 60: (1, {'@': 901}), 57: (1, {'@': 901})}, 62: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 194: (0, 1979), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 86: (0, 2015), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 63: {193: (0, 53), 192: (0, 47), 60: (1, {'@': 737}), 57: (1, {'@': 737})}, 64: {128: (0, 14), 129: (0, 12), 130: (0, 11), 131: (0, 10), 132: (0, 8), 133: (0, 4), 134: (0, 13), 140: (0, 3), 136: (0, 9), 137: (0, 5), 138: (0, 6), 139: (0, 18), 141: (0, 49), 142: (0, 46), 196: (0, 31), 143: (0, 26)}, 65: {126: (0, 669), 146: (1, {'@': 1550}), 60: (1, {'@': 1550})}, 66: {60: (1, {'@': 359}), 57: (1, {'@': 359})}, 67: {60: (1, {'@': 315}), 57: (1, {'@': 315})}, 68: {60: (1, {'@': 307}), 57: (1, {'@': 307})}, 69: {60: (1, {'@': 355}), 57: (1, {'@': 355})}, 70: {36: (0, 15), 197: (0, 16), 60: (1, {'@': 531}), 57: (1, {'@': 531})}, 71: {60: (1, {'@': 1237}), 57: (1, {'@': 1237})}, 72: {198: (0, 393), 22: (0, 389), 53: (0, 387), 33: (0, 383), 7: (0, 45), 199: (0, 379), 44: (0, 358), 41: (0, 372), 62: (0, 367), 21: (0, 366), 59: (0, 363), 200: (0, 395), 180: (0, 359), 201: (0, 354), 183: (0, 351), 202: (0, 350), 164: (0, 347), 75: (0, 341), 203: (0, 402), 204: (0, 304), 49: (0, 335), 205: (0, 334), 28: (0, 33), 206: (0, 330), 61: (0, 25), 23: (0, 327), 185: (0, 324), 207: (0, 320), 208: (0, 303), 209: (0, 1753), 40: (0, 1756), 69: (0, 1760), 73: (0, 1763), 172: (0, 1765), 210: (0, 1769), 211: (0, 1774), 6: (0, 20), 212: (0, 1778), 25: (0, 1783), 213: (0, 1788), 0: (1, {'@': 432}), 3: (1, {'@': 432}), 20: (1, {'@': 432}), 32: (1, {'@': 432}), 65: (1, {'@': 432}), 10: (1, {'@': 432}), 35: (1, {'@': 432}), 12: (1, {'@': 432}), 46: (1, {'@': 432}), 24: (1, {'@': 432}), 14: (1, {'@': 432}), 13: (1, {'@': 432}), 39: (1, {'@': 432}), 42: (1, {'@': 432}), 56: (1, {'@': 432}), 16: (1, {'@': 432}), 5: (1, {'@': 432}), 19: (1, {'@': 432})}, 73: {144: (0, 2316), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 145: (0, 344), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 86: (0, 2471), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 74: {60: (1, {'@': 305}), 57: (1, {'@': 305})}, 75: {60: (1, {'@': 353}), 57: (1, {'@': 353})}, 76: {60: (1, {'@': 333}), 57: (1, {'@': 333})}, 77: {60: (1, {'@': 345}), 57: (1, {'@': 345})}, 78: {60: (1, {'@': 311}), 57: (1, {'@': 311})}, 79: {214: (0, 301), 4: (0, 405), 7: (0, 45), 161: (0, 413), 27: (0, 408), 215: (0, 1790), 50: (0, 1792), 26: (0, 1797), 216: (0, 1802), 180: (0, 1807), 38: (0, 1811), 183: (0, 1813), 167: (0, 1817), 28: (0, 33), 61: (0, 25), 47: (0, 1820), 164: (0, 1824), 37: (0, 1828), 45: (0, 1833), 169: (0, 1836), 163: (0, 1842), 165: (0, 1846), 6: (0, 20), 185: (0, 1849), 168: (0, 1853), 217: (0, 1857), 0: (1, {'@': 427}), 3: (1, {'@': 427}), 20: (1, {'@': 427}), 32: (1, {'@': 427}), 65: (1, {'@': 427}), 10: (1, {'@': 427}), 35: (1, {'@': 427}), 12: (1, {'@': 427}), 46: (1, {'@': 427}), 24: (1, {'@': 427}), 14: (1, {'@': 427}), 13: (1, {'@': 427}), 39: (1, {'@': 427}), 42: (1, {'@': 427}), 56: (1, {'@': 427}), 16: (1, {'@': 427}), 5: (1, {'@': 427}), 19: (1, {'@': 427}), 60: (1, {'@': 936}), 57: (1, {'@': 936})}, 80: {171: (0, 35), 161: (0, 1867), 53: (0, 387), 4: (0, 405), 29: (0, 1870), 162: (0, 1874), 163: (0, 1879), 27: (0, 408), 164: (0, 1881), 26: (0, 1797), 38: (0, 1811), 218: (0, 1885), 165: (0, 1888), 166: (0, 1893), 167: (0, 1898), 168: (0, 1903), 61: (0, 25), 15: (0, 1909), 67: (0, 1913), 169: (0, 1917), 37: (0, 1828), 45: (0, 1833), 30: (0, 1920), 170: (0, 1924), 172: (0, 1929), 173: (0, 1933), 0: (1, {'@': 421}), 3: (1, {'@': 421}), 20: (1, {'@': 421}), 32: (1, {'@': 421}), 65: (1, {'@': 421}), 10: (1, {'@': 421}), 35: (1, {'@': 421}), 12: (1, {'@': 421}), 46: (1, {'@': 421}), 24: (1, {'@': 421}), 14: (1, {'@': 421}), 13: (1, {'@': 421}), 39: (1, {'@': 421}), 42: (1, {'@': 421}), 56: (1, {'@': 421}), 16: (1, {'@': 421}), 5: (1, {'@': 421}), 19: (1, {'@': 421}), 60: (1, {'@': 868}), 57: (1, {'@': 868})}, 81: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 1830), 12: (0, 1939), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 1957), 78: (0, 1960), 14: (0, 1965), 86: (0, 1968), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 219: (0, 795), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 82: {60: (1, {'@': 1077}), 125: (1, {'@': 1077}), 126: (1, {'@': 1077}), 53: (1, {'@': 1077}), 127: (1, {'@': 1077}), 41: (1, {'@': 1077}), 57: (1, {'@': 1077})}, 83: {144: (0, 2316), 115: (0, 44), 77: (0, 17), 108: (0, 400), 86: (0, 1055), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 145: (0, 1046), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 84: {112: (0, 1677)}, 85: {193: (0, 53), 192: (0, 2113)}, 86: {112: (0, 7), 220: (0, 869), 197: (0, 870), 221: (0, 872), 36: (0, 15), 222: (0, 874), 223: (0, 876), 224: (0, 878), 225: (0, 879), 226: (0, 883), 227: (0, 885), 228: (0, 887), 229: (0, 889)}, 87: {230: (0, 891), 231: (0, 893), 232: (0, 895), 233: (0, 898), 234: (0, 900), 235: (0, 901), 236: (0, 903), 237: (0, 905), 238: (0, 907), 239: (0, 910), 240: (0, 912), 241: (0, 914), 242: (0, 916), 243: (0, 917), 244: (0, 919), 245: (0, 921)}, 88: {60: (1, {'@': 932}), 57: (1, {'@': 932})}, 89: {60: (1, {'@': 314}), 57: (1, {'@': 314})}, 90: {60: (1, {'@': 318}), 57: (1, {'@': 318})}, 91: {41: (0, 372), 246: (0, 2), 247: (0, 82), 201: (0, 923), 248: (0, 925), 125: (0, 928), 53: (0, 387), 127: (0, 930), 172: (0, 933), 249: (0, 935), 60: (1, {'@': 1072}), 57: (1, {'@': 1072})}, 92: {112: (0, 60)}, 93: {250: (0, 938), 175: (0, 940), 22: (0, 389), 251: (0, 942), 7: (0, 45), 252: (0, 944), 49: (0, 335), 180: (0, 945), 206: (0, 947), 198: (0, 949), 176: (0, 951), 174: (0, 953), 253: (0, 954), 254: (0, 956)}, 94: {144: (0, 2316), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 255: (0, 1221), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 86: (0, 1279), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 145: (0, 1276), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 256: (0, 1293), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 257: (0, 1296), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 95: {180: (0, 88), 7: (0, 45), 0: (1, {'@': 425}), 3: (1, {'@': 425}), 20: (1, {'@': 425}), 32: (1, {'@': 425}), 65: (1, {'@': 425}), 10: (1, {'@': 425}), 35: (1, {'@': 425}), 12: (1, {'@': 425}), 46: (1, {'@': 425}), 24: (1, {'@': 425}), 14: (1, {'@': 425}), 13: (1, {'@': 425}), 39: (1, {'@': 425}), 42: (1, {'@': 425}), 56: (1, {'@': 425}), 16: (1, {'@': 425}), 5: (1, {'@': 425}), 19: (1, {'@': 425}), 60: (1, {'@': 933}), 57: (1, {'@': 933})}, 96: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 86: (0, 1309), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 89: (0, 2384), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 194: (0, 1313), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 97: {35: (0, 0), 0: (0, 102), 12: (0, 936), 56: (0, 959), 5: (0, 960), 46: (0, 962), 258: (0, 965), 19: (0, 970), 24: (0, 971), 16: (0, 972), 14: (0, 973), 20: (0, 975), 259: (0, 977), 3: (0, 979), 13: (0, 981), 10: (0, 983), 42: (0, 984), 32: (0, 986), 39: (0, 989), 65: (0, 991)}, 98: {112: (0, 62), 57: (1, {'@': 527}), 60: (1, {'@': 527})}, 99: {60: (1, {'@': 312}), 57: (1, {'@': 312})}, 100: {60: (1, {'@': 348}), 57: (1, {'@': 348})}, 101: {260: (0, 997), 192: (0, 999), 193: (0, 53), 261: (0, 1005), 262: (0, 1008), 263: (0, 1013), 264: (0, 1014), 60: (1, {'@': 794}), 57: (1, {'@': 794})}, 102: {0: (1, {'@': 428}), 1: (1, {'@': 428}), 2: (1, {'@': 428}), 3: (1, {'@': 428}), 4: (1, {'@': 428}), 5: (1, {'@': 428}), 6: (1, {'@': 428}), 7: (1, {'@': 428}), 8: (1, {'@': 428}), 9: (1, {'@': 428}), 10: (1, {'@': 428}), 11: (1, {'@': 428}), 12: (1, {'@': 428}), 13: (1, {'@': 428}), 14: (1, {'@': 428}), 15: (1, {'@': 428}), 16: (1, {'@': 428}), 17: (1, {'@': 428}), 18: (1, {'@': 428}), 19: (1, {'@': 428}), 20: (1, {'@': 428}), 21: (1, {'@': 428}), 22: (1, {'@': 428}), 23: (1, {'@': 428}), 24: (1, {'@': 428}), 25: (1, {'@': 428}), 26: (1, {'@': 428}), 27: (1, {'@': 428}), 28: (1, {'@': 428}), 29: (1, {'@': 428}), 30: (1, {'@': 428}), 31: (1, {'@': 428}), 32: (1, {'@': 428}), 33: (1, {'@': 428}), 34: (1, {'@': 428}), 35: (1, {'@': 428}), 36: (1, {'@': 428}), 37: (1, {'@': 428}), 38: (1, {'@': 428}), 39: (1, {'@': 428}), 40: (1, {'@': 428}), 41: (1, {'@': 428}), 42: (1, {'@': 428}), 43: (1, {'@': 428}), 44: (1, {'@': 428}), 45: (1, {'@': 428}), 46: (1, {'@': 428}), 47: (1, {'@': 428}), 48: (1, {'@': 428}), 49: (1, {'@': 428}), 50: (1, {'@': 428}), 51: (1, {'@': 428}), 52: (1, {'@': 428}), 53: (1, {'@': 428}), 54: (1, {'@': 428}), 55: (1, {'@': 428}), 56: (1, {'@': 428}), 57: (1, {'@': 428}), 58: (1, {'@': 428}), 59: (1, {'@': 428}), 60: (1, {'@': 428}), 61: (1, {'@': 428}), 62: (1, {'@': 428}), 63: (1, {'@': 428}), 64: (1, {'@': 428}), 65: (1, {'@': 428}), 66: (1, {'@': 428}), 67: (1, {'@': 428}), 68: (1, {'@': 428}), 69: (1, {'@': 428}), 70: (1, {'@': 428}), 71: (1, {'@': 428}), 72: (1, {'@': 428}), 73: (1, {'@': 428}), 74: (1, {'@': 428}), 75: (1, {'@': 428})}, 103: {60: (1, {'@': 316}), 57: (1, {'@': 316})}, 104: {112: (0, 313), 60: (1, {'@': 1234}), 57: (1, {'@': 1234})}, 105: {265: (0, 993), 4: (0, 405), 266: (0, 1016), 267: (0, 1017), 112: (0, 1021), 268: (0, 1462), 269: (0, 1465), 67: (0, 1913), 166: (0, 1468), 270: (0, 1470), 30: (0, 1920), 162: (0, 1472), 161: (0, 1476), 271: (0, 1479), 272: (0, 1483), 60: (1, {'@': 612}), 57: (1, {'@': 612})}, 106: {273: (0, 1715), 274: (0, 92), 275: (0, 98), 276: (0, 36), 277: (0, 1486), 278: (0, 1491), 279: (0, 1495)}, 107: {64: (0, 1537), 53: (0, 387), 41: (0, 372), 280: (0, 1542), 38: (0, 1811), 281: (0, 1545), 43: (0, 1548), 61: (0, 25), 165: (0, 1553), 69: (0, 1760), 45: (0, 1833), 282: (0, 1555), 204: (0, 1565), 185: (0, 1569), 208: (0, 1573), 6: (0, 20), 44: (0, 358), 40: (0, 1756), 168: (0, 1577), 33: (0, 383), 18: (0, 1581), 21: (0, 366), 283: (0, 1585), 34: (0, 1589), 28: (0, 33), 284: (0, 1594), 54: (0, 1598), 37: (0, 1828), 211: (0, 1602), 183: (0, 1607), 285: (0, 1610), 74: (0, 1616), 27: (0, 408), 172: (0, 1620), 167: (0, 1625), 200: (0, 1627), 210: (0, 1631), 164: (0, 1635), 286: (0, 1640), 75: (0, 341), 207: (0, 1646), 201: (0, 1650), 287: (0, 1654), 169: (0, 1657), 0: (1, {'@': 431}), 3: (1, {'@': 431}), 20: (1, {'@': 431}), 32: (1, {'@': 431}), 65: (1, {'@': 431}), 10: (1, {'@': 431}), 35: (1, {'@': 431}), 12: (1, {'@': 431}), 46: (1, {'@': 431}), 24: (1, {'@': 431}), 14: (1, {'@': 431}), 13: (1, {'@': 431}), 39: (1, {'@': 431}), 42: (1, {'@': 431}), 56: (1, {'@': 431}), 16: (1, {'@': 431}), 5: (1, {'@': 431}), 19: (1, {'@': 431}), 60: (1, {'@': 1026}), 57: (1, {'@': 1026})}, 108: {60: (1, {'@': 547}), 57: (1, {'@': 547})}, 109: {288: (0, 1534), 289: (0, 1516), 290: (0, 1521), 8: (0, 1510), 291: (0, 1519), 52: (0, 1498), 292: (0, 1531), 293: (0, 1500), 60: (1, {'@': 739}), 57: (1, {'@': 739})}, 110: {58: (0, 1666), 172: (0, 1671), 53: (0, 387), 294: (0, 1675), 33: (0, 383), 44: (0, 358), 66: (0, 1679), 210: (0, 1680), 183: (0, 1685), 295: (0, 1688), 28: (0, 33), 165: (0, 1693), 204: (0, 1696), 296: (0, 1701), 37: (0, 1828), 297: (0, 1706), 6: (0, 20), 185: (0, 1710), 0: (1, {'@': 420}), 3: (1, {'@': 420}), 20: (1, {'@': 420}), 32: (1, {'@': 420}), 65: (1, {'@': 420}), 10: (1, {'@': 420}), 35: (1, {'@': 420}), 12: (1, {'@': 420}), 46: (1, {'@': 420}), 24: (1, {'@': 420}), 14: (1, {'@': 420}), 13: (1, {'@': 420}), 39: (1, {'@': 420}), 42: (1, {'@': 420}), 56: (1, {'@': 420}), 16: (1, {'@': 420}), 5: (1, {'@': 420}), 19: (1, {'@': 420}), 60: (1, {'@': 847}), 57: (1, {'@': 847})}, 111: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 86: (0, 2453), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 194: (0, 2456), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 112: {298: (0, 995), 299: (0, 1524), 193: (0, 53), 192: (0, 1665), 300: (0, 1721), 60: (1, {'@': 761}), 57: (1, {'@': 761})}, 113: {301: (0, 1723), 7: (0, 45), 185: (0, 1730), 183: (0, 1733), 28: (0, 33), 164: (0, 1736), 61: (0, 25), 37: (0, 1828), 180: (0, 1741), 302: (0, 1746), 6: (0, 20), 165: (0, 1750), 60: (1, {'@': 912}), 57: (1, {'@': 912})}, 114: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 86: (0, 2242), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 303: (0, 2442), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 115: {60: (1, {'@': 349}), 57: (1, {'@': 349})}, 116: {304: (0, 108), 305: (0, 306), 306: (0, 1770), 60: (1, {'@': 548}), 57: (1, {'@': 548})}, 117: {60: (1, {'@': 357}), 57: (1, {'@': 357})}, 118: {60: (1, {'@': 350}), 57: (1, {'@': 350})}, 119: {164: (0, 1776), 27: (0, 408), 183: (0, 1779), 26: (0, 1797), 167: (0, 1782), 38: (0, 1811), 28: (0, 33), 307: (0, 1784), 163: (0, 1786), 61: (0, 25), 308: (0, 1789), 1: (0, 1793), 185: (0, 1796), 45: (0, 1833), 169: (0, 1798), 168: (0, 1803), 6: (0, 20), 309: (0, 1808), 0: (1, {'@': 428}), 3: (1, {'@': 428}), 20: (1, {'@': 428}), 32: (1, {'@': 428}), 65: (1, {'@': 428}), 10: (1, {'@': 428}), 35: (1, {'@': 428}), 12: (1, {'@': 428}), 46: (1, {'@': 428}), 24: (1, {'@': 428}), 14: (1, {'@': 428}), 13: (1, {'@': 428}), 39: (1, {'@': 428}), 42: (1, {'@': 428}), 56: (1, {'@': 428}), 16: (1, {'@': 428}), 5: (1, {'@': 428}), 19: (1, {'@': 428}), 60: (1, {'@': 972}), 57: (1, {'@': 972})}, 120: {60: (1, {'@': 1126}), 57: (1, {'@': 1126})}, 121: {310: (0, 454), 311: (0, 2361), 312: (0, 457), 313: (0, 2377), 314: (0, 2369)}, 122: {57: (1, {'@': 849}), 60: (1, {'@': 849})}, 123: {58: (0, 1666), 172: (0, 1671), 53: (0, 387), 33: (0, 383), 44: (0, 358), 66: (0, 1679), 210: (0, 1680), 183: (0, 1685), 295: (0, 1688), 28: (0, 33), 294: (0, 2116), 165: (0, 1693), 204: (0, 1696), 296: (0, 1701), 37: (0, 1828), 6: (0, 20), 185: (0, 1710)}, 124: {57: (1, {'@': 622}), 60: (1, {'@': 622}), 61: (1, {'@': 622}), 53: (1, {'@': 622}), 67: (1, {'@': 622}), 126: (1, {'@': 622}), 37: (1, {'@': 622}), 45: (1, {'@': 622}), 38: (1, {'@': 622}), 26: (1, {'@': 622}), 27: (1, {'@': 622}), 4: (1, {'@': 622}), 29: (1, {'@': 622}), 30: (1, {'@': 622}), 15: (1, {'@': 622}), 268: (1, {'@': 622}), 270: (1, {'@': 622}), 266: (1, {'@': 622}), 43: (1, {'@': 622}), 1: (1, {'@': 622}), 2: (1, {'@': 622}), 44: (1, {'@': 622}), 47: (1, {'@': 622}), 48: (1, {'@': 622}), 49: (1, {'@': 622}), 50: (1, {'@': 622}), 51: (1, {'@': 622}), 6: (1, {'@': 622}), 52: (1, {'@': 622}), 8: (1, {'@': 622}), 7: (1, {'@': 622}), 9: (1, {'@': 622}), 11: (1, {'@': 622}), 54: (1, {'@': 622}), 55: (1, {'@': 622}), 17: (1, {'@': 622}), 18: (1, {'@': 622}), 58: (1, {'@': 622}), 59: (1, {'@': 622}), 21: (1, {'@': 622}), 22: (1, {'@': 622}), 62: (1, {'@': 622}), 23: (1, {'@': 622}), 25: (1, {'@': 622}), 63: (1, {'@': 622}), 28: (1, {'@': 622}), 31: (1, {'@': 622}), 33: (1, {'@': 622}), 64: (1, {'@': 622}), 66: (1, {'@': 622}), 34: (1, {'@': 622}), 36: (1, {'@': 622}), 68: (1, {'@': 622}), 69: (1, {'@': 622}), 70: (1, {'@': 622}), 71: (1, {'@': 622}), 40: (1, {'@': 622}), 72: (1, {'@': 622}), 41: (1, {'@': 622}), 73: (1, {'@': 622}), 74: (1, {'@': 622}), 75: (1, {'@': 622})}, 125: {146: (0, 520)}, 126: {80: (0, 2414), 81: (0, 2295), 194: (0, 495), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 127: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 194: (0, 442), 10: (0, 826), 100: (0, 817), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 86: (0, 462), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 128: {86: (0, 449), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 194: (0, 438), 85: (0, 816), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 118: (0, 819), 10: (0, 826), 100: (0, 817), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 129: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 312: (0, 469), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 313: (0, 2377), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 86: (0, 472), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 130: {78: (0, 52), 32: (0, 61), 96: (0, 63), 119: (0, 64), 315: (0, 66), 316: (0, 67), 317: (0, 68), 318: (0, 69), 99: (0, 70), 91: (0, 71), 19: (0, 72), 319: (0, 74), 320: (0, 75), 321: (0, 76), 322: (0, 77), 323: (0, 78), 16: (0, 79), 13: (0, 80), 118: (0, 81), 115: (0, 86), 105: (0, 87), 324: (0, 89), 325: (0, 90), 122: (0, 91), 85: (0, 93), 39: (0, 95), 259: (0, 97), 326: (0, 99), 327: (0, 100), 114: (0, 101), 328: (0, 103), 124: (0, 104), 84: (0, 105), 102: (0, 106), 3: (0, 107), 113: (0, 109), 65: (0, 110), 90: (0, 112), 94: (0, 113), 329: (0, 115), 95: (0, 116), 330: (0, 117), 331: (0, 118), 0: (0, 119), 110: (0, 1461), 332: (0, 1464), 46: (0, 1467), 333: (0, 1475), 93: (0, 1477), 24: (0, 1485), 111: (0, 1493), 120: (0, 1499), 98: (0, 1503), 117: (0, 1504), 56: (0, 1511), 334: (0, 1514), 14: (0, 1515), 5: (0, 1526), 335: (0, 1533), 108: (0, 1536), 336: (0, 1539), 20: (0, 1541), 337: (0, 1547), 79: (0, 1550), 10: (0, 1552), 338: (0, 1559), 77: (0, 1563), 339: (0, 1564), 340: (0, 1568), 83: (0, 1570), 103: (0, 1572), 341: (0, 1586), 342: (0, 1588), 123: (0, 1591), 343: (0, 1091), 344: (0, 1593), 345: (0, 1595), 346: (0, 1597), 347: (0, 1599), 348: (0, 1601), 82: (0, 1605), 349: (0, 1613), 350: (0, 1615), 100: (0, 1618), 116: (0, 1630), 106: (0, 1634), 351: (0, 1645), 352: (0, 1647), 353: (0, 1649), 354: (0, 1651), 88: (0, 1653), 355: (0, 1662), 356: (0, 1663), 35: (0, 1664), 92: (0, 1672), 357: (0, 1682), 12: (0, 1684), 87: (0, 1692), 358: (0, 1700), 359: (0, 1702), 360: (0, 1705), 361: (0, 1707), 362: (0, 1709), 42: (0, 1712), 363: (0, 1720), 364: (0, 1722), 365: (0, 1725), 366: (0, 1726), 109: (0, 1729), 367: (0, 1735), 368: (0, 1738), 369: (0, 1740), 370: (0, 1744), 371: (0, 1745), 372: (0, 1748), 373: (0, 1749)}, 131: {306: (0, 1770), 374: (0, 140), 375: (0, 2114), 305: (0, 2109)}, 132: {374: (1, {'@': 1624}), 60: (1, {'@': 1624}), 126: (1, {'@': 1624}), 57: (1, {'@': 1624}), 306: (1, {'@': 1624})}, 133: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 86: (0, 493), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 134: {57: (1, {'@': 914}), 60: (1, {'@': 914})}, 135: {61: (0, 25), 37: (0, 1828), 165: (0, 1750), 7: (0, 45), 28: (0, 33), 6: (0, 20), 185: (0, 1730), 164: (0, 1736), 301: (0, 2127), 180: (0, 1741), 183: (0, 1733)}, 136: {57: (1, {'@': 895}), 60: (1, {'@': 895}), 61: (1, {'@': 895}), 53: (1, {'@': 895}), 67: (1, {'@': 895}), 126: (1, {'@': 895}), 37: (1, {'@': 895}), 45: (1, {'@': 895}), 38: (1, {'@': 895}), 26: (1, {'@': 895}), 27: (1, {'@': 895}), 4: (1, {'@': 895}), 29: (1, {'@': 895}), 30: (1, {'@': 895}), 15: (1, {'@': 895}), 43: (1, {'@': 895}), 1: (1, {'@': 895}), 2: (1, {'@': 895}), 44: (1, {'@': 895}), 47: (1, {'@': 895}), 48: (1, {'@': 895}), 49: (1, {'@': 895}), 50: (1, {'@': 895}), 51: (1, {'@': 895}), 6: (1, {'@': 895}), 52: (1, {'@': 895}), 8: (1, {'@': 895}), 7: (1, {'@': 895}), 9: (1, {'@': 895}), 11: (1, {'@': 895}), 54: (1, {'@': 895}), 55: (1, {'@': 895}), 17: (1, {'@': 895}), 18: (1, {'@': 895}), 58: (1, {'@': 895}), 59: (1, {'@': 895}), 21: (1, {'@': 895}), 22: (1, {'@': 895}), 62: (1, {'@': 895}), 23: (1, {'@': 895}), 25: (1, {'@': 895}), 63: (1, {'@': 895}), 28: (1, {'@': 895}), 31: (1, {'@': 895}), 33: (1, {'@': 895}), 64: (1, {'@': 895}), 66: (1, {'@': 895}), 34: (1, {'@': 895}), 36: (1, {'@': 895}), 68: (1, {'@': 895}), 69: (1, {'@': 895}), 70: (1, {'@': 895}), 71: (1, {'@': 895}), 40: (1, {'@': 895}), 72: (1, {'@': 895}), 41: (1, {'@': 895}), 73: (1, {'@': 895}), 74: (1, {'@': 895}), 75: (1, {'@': 895})}, 137: {60: (1, {'@': 1344}), 57: (1, {'@': 1344})}, 138: {57: (1, {'@': 885}), 60: (1, {'@': 885}), 61: (1, {'@': 885}), 53: (1, {'@': 885}), 67: (1, {'@': 885}), 126: (1, {'@': 885}), 37: (1, {'@': 885}), 45: (1, {'@': 885}), 38: (1, {'@': 885}), 26: (1, {'@': 885}), 27: (1, {'@': 885}), 4: (1, {'@': 885}), 29: (1, {'@': 885}), 30: (1, {'@': 885}), 15: (1, {'@': 885}), 43: (1, {'@': 885}), 1: (1, {'@': 885}), 2: (1, {'@': 885}), 44: (1, {'@': 885}), 47: (1, {'@': 885}), 48: (1, {'@': 885}), 49: (1, {'@': 885}), 50: (1, {'@': 885}), 51: (1, {'@': 885}), 6: (1, {'@': 885}), 52: (1, {'@': 885}), 8: (1, {'@': 885}), 7: (1, {'@': 885}), 9: (1, {'@': 885}), 11: (1, {'@': 885}), 54: (1, {'@': 885}), 55: (1, {'@': 885}), 17: (1, {'@': 885}), 18: (1, {'@': 885}), 58: (1, {'@': 885}), 59: (1, {'@': 885}), 21: (1, {'@': 885}), 22: (1, {'@': 885}), 62: (1, {'@': 885}), 23: (1, {'@': 885}), 25: (1, {'@': 885}), 63: (1, {'@': 885}), 28: (1, {'@': 885}), 31: (1, {'@': 885}), 33: (1, {'@': 885}), 64: (1, {'@': 885}), 66: (1, {'@': 885}), 34: (1, {'@': 885}), 36: (1, {'@': 885}), 68: (1, {'@': 885}), 69: (1, {'@': 885}), 70: (1, {'@': 885}), 71: (1, {'@': 885}), 40: (1, {'@': 885}), 72: (1, {'@': 885}), 41: (1, {'@': 885}), 73: (1, {'@': 885}), 74: (1, {'@': 885}), 75: (1, {'@': 885})}, 139: {144: (0, 2316), 376: (0, 528), 115: (0, 44), 77: (0, 17), 108: (0, 400), 145: (0, 526), 109: (0, 390), 92: (0, 1944), 255: (0, 1221), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 377: (0, 553), 19: (0, 800), 13: (0, 802), 378: (0, 559), 379: (0, 540), 117: (0, 804), 86: (0, 543), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 42: (0, 858), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 380: (0, 1402), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 381: (0, 547), 90: (0, 853), 3: (0, 855), 123: (0, 856), 256: (0, 550), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 140: {112: (0, 2126), 57: (1, {'@': 562}), 60: (1, {'@': 562})}, 141: {144: (0, 2316), 145: (0, 475)}, 142: {382: (0, 2422), 383: (0, 496)}, 143: {57: (1, {'@': 553}), 60: (1, {'@': 553})}, 144: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 483)}, 145: {306: (0, 1770), 374: (0, 140), 126: (0, 2134), 305: (0, 2141), 375: (0, 2142), 57: (1, {'@': 551}), 60: (1, {'@': 551})}, 146: {57: (1, {'@': 640}), 60: (1, {'@': 640}), 61: (1, {'@': 640}), 53: (1, {'@': 640}), 67: (1, {'@': 640}), 126: (1, {'@': 640}), 37: (1, {'@': 640}), 45: (1, {'@': 640}), 38: (1, {'@': 640}), 26: (1, {'@': 640}), 27: (1, {'@': 640}), 4: (1, {'@': 640}), 29: (1, {'@': 640}), 30: (1, {'@': 640}), 15: (1, {'@': 640}), 268: (1, {'@': 640}), 270: (1, {'@': 640}), 266: (1, {'@': 640}), 43: (1, {'@': 640}), 1: (1, {'@': 640}), 2: (1, {'@': 640}), 44: (1, {'@': 640}), 47: (1, {'@': 640}), 48: (1, {'@': 640}), 49: (1, {'@': 640}), 50: (1, {'@': 640}), 51: (1, {'@': 640}), 6: (1, {'@': 640}), 52: (1, {'@': 640}), 8: (1, {'@': 640}), 7: (1, {'@': 640}), 9: (1, {'@': 640}), 11: (1, {'@': 640}), 54: (1, {'@': 640}), 55: (1, {'@': 640}), 17: (1, {'@': 640}), 18: (1, {'@': 640}), 58: (1, {'@': 640}), 59: (1, {'@': 640}), 21: (1, {'@': 640}), 22: (1, {'@': 640}), 62: (1, {'@': 640}), 23: (1, {'@': 640}), 25: (1, {'@': 640}), 63: (1, {'@': 640}), 28: (1, {'@': 640}), 31: (1, {'@': 640}), 33: (1, {'@': 640}), 64: (1, {'@': 640}), 66: (1, {'@': 640}), 34: (1, {'@': 640}), 36: (1, {'@': 640}), 68: (1, {'@': 640}), 69: (1, {'@': 640}), 70: (1, {'@': 640}), 71: (1, {'@': 640}), 40: (1, {'@': 640}), 72: (1, {'@': 640}), 41: (1, {'@': 640}), 73: (1, {'@': 640}), 74: (1, {'@': 640}), 75: (1, {'@': 640})}, 147: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 194: (0, 620), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 86: (0, 611), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 148: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 384: (0, 466), 79: (0, 1973), 116: (0, 780), 385: (0, 478), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 86: (0, 488), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 386: (0, 491), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 149: {387: (0, 1852), 388: (0, 2155)}, 150: {144: (0, 2316), 145: (0, 498)}, 151: {144: (0, 2316), 115: (0, 44), 77: (0, 17), 86: (0, 2165), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 145: (0, 2166), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 152: {57: (1, {'@': 974}), 60: (1, {'@': 974})}, 153: {164: (0, 1776), 27: (0, 408), 308: (0, 2144), 183: (0, 1779), 26: (0, 1797), 167: (0, 1782), 38: (0, 1811), 28: (0, 33), 163: (0, 1786), 61: (0, 25), 1: (0, 1793), 185: (0, 1796), 45: (0, 1833), 169: (0, 1798), 168: (0, 1803), 6: (0, 20), 309: (0, 1808)}, 154: {230: (1, {'@': 725}), 60: (1, {'@': 725}), 235: (1, {'@': 725}), 240: (1, {'@': 725}), 126: (1, {'@': 725}), 231: (1, {'@': 725}), 234: (1, {'@': 725}), 57: (1, {'@': 725}), 241: (1, {'@': 725}), 243: (1, {'@': 725})}, 155: {60: (1, {'@': 1360}), 57: (1, {'@': 1360})}, 156: {53: (0, 387), 172: (0, 492)}, 157: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 86: (0, 614), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 194: (0, 624), 102: (0, 823), 103: (0, 825), 14: (0, 399), 20: (0, 822), 10: (0, 826), 100: (0, 817), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 158: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 194: (0, 485), 86: (0, 487), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 159: {57: (1, {'@': 526}), 60: (1, {'@': 526})}, 160: {144: (0, 2316), 376: (0, 528), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 255: (0, 1221), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 389: (0, 529), 116: (0, 780), 46: (0, 781), 145: (0, 532), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 377: (0, 534), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 379: (0, 540), 117: (0, 804), 86: (0, 543), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 42: (0, 858), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 380: (0, 1402), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 381: (0, 547), 90: (0, 853), 3: (0, 855), 123: (0, 856), 256: (0, 550), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 161: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 194: (0, 430), 81: (0, 2295), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 86: (0, 433), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 162: {60: (1, {'@': 666}), 126: (1, {'@': 666}), 222: (1, {'@': 666}), 220: (1, {'@': 666}), 36: (1, {'@': 666}), 221: (1, {'@': 666}), 223: (1, {'@': 666}), 57: (1, {'@': 666})}, 163: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 194: (0, 465), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 86: (0, 468), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 164: {144: (0, 2316), 145: (0, 506)}, 165: {22: (0, 389), 48: (0, 1843), 7: (0, 45), 390: (0, 1819), 177: (0, 1812), 49: (0, 335), 391: (0, 1837), 179: (0, 1835), 206: (0, 1935), 198: (0, 1940), 72: (0, 1882), 392: (0, 1945), 178: (0, 1950), 180: (0, 1955), 393: (0, 2207), 126: (0, 2209), 394: (0, 1961), 395: (0, 1966), 60: (1, {'@': 589}), 57: (1, {'@': 589})}, 166: {60: (1, {'@': 671}), 126: (1, {'@': 671}), 222: (1, {'@': 671}), 220: (1, {'@': 671}), 36: (1, {'@': 671}), 221: (1, {'@': 671}), 223: (1, {'@': 671}), 57: (1, {'@': 671})}, 167: {60: (1, {'@': 669}), 126: (1, {'@': 669}), 222: (1, {'@': 669}), 220: (1, {'@': 669}), 36: (1, {'@': 669}), 221: (1, {'@': 669}), 223: (1, {'@': 669}), 57: (1, {'@': 669})}, 168: {144: (0, 2316), 115: (0, 44), 77: (0, 17), 108: (0, 400), 145: (0, 2335), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 86: (0, 2180), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 169: {144: (0, 2316), 145: (0, 502)}, 170: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 194: (0, 2201), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 86: (0, 2178), 119: (0, 836), 120: (0, 840), 106: (0, 838), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 171: {230: (1, {'@': 728}), 60: (1, {'@': 728}), 235: (1, {'@': 728}), 240: (1, {'@': 728}), 126: (1, {'@': 728}), 231: (1, {'@': 728}), 234: (1, {'@': 728}), 57: (1, {'@': 728}), 241: (1, {'@': 728}), 243: (1, {'@': 728})}, 172: {60: (1, {'@': 1138}), 57: (1, {'@': 1138})}, 173: {200: (0, 1840), 22: (0, 389), 48: (0, 1843), 53: (0, 387), 58: (0, 1666), 33: (0, 383), 183: (0, 1844), 7: (0, 45), 197: (0, 1847), 164: (0, 1850), 59: (0, 363), 208: (0, 1854), 396: (0, 1858), 75: (0, 341), 36: (0, 15), 397: (0, 2170), 49: (0, 335), 172: (0, 1861), 28: (0, 33), 212: (0, 1865), 180: (0, 1871), 34: (0, 1589), 61: (0, 25), 72: (0, 1882), 206: (0, 1884), 69: (0, 1760), 204: (0, 1887), 198: (0, 1891), 296: (0, 1896), 6: (0, 20), 31: (0, 1901), 9: (0, 1906), 392: (0, 1911), 185: (0, 1918), 395: (0, 1921), 398: (0, 1926), 287: (0, 1931)}, 174: {80: (0, 2434), 81: (0, 2295), 107: (0, 2409), 399: (0, 511), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 175: {112: (1, {'@': 1704}), 89: (1, {'@': 1704}), 97: (1, {'@': 1704}), 107: (1, {'@': 1704}), 126: (1, {'@': 1704}), 146: (1, {'@': 1704}), 60: (1, {'@': 1704})}, 176: {86: (0, 732), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 177: {268: (1, {'@': 642}), 60: (1, {'@': 642}), 126: (1, {'@': 642}), 67: (1, {'@': 642}), 270: (1, {'@': 642}), 4: (1, {'@': 642}), 266: (1, {'@': 642}), 30: (1, {'@': 642}), 57: (1, {'@': 642})}, 178: {177: (1, {'@': 1636}), 7: (1, {'@': 1636}), 22: (1, {'@': 1636}), 60: (1, {'@': 1636}), 126: (1, {'@': 1636}), 48: (1, {'@': 1636}), 72: (1, {'@': 1636}), 178: (1, {'@': 1636}), 179: (1, {'@': 1636}), 49: (1, {'@': 1636}), 57: (1, {'@': 1636})}, 179: {22: (0, 389), 48: (0, 1843), 7: (0, 45), 390: (0, 1819), 177: (0, 1812), 393: (0, 2205), 49: (0, 335), 391: (0, 1837), 179: (0, 1835), 206: (0, 1935), 198: (0, 1940), 72: (0, 1882), 392: (0, 1945), 178: (0, 1950), 180: (0, 1955), 394: (0, 1961), 395: (0, 1966)}, 180: {80: (0, 2414), 81: (0, 2295), 194: (0, 521), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 181: {400: (0, 1799), 401: (0, 2305)}, 182: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 519)}, 183: {22: (0, 389), 53: (0, 387), 7: (0, 45), 198: (0, 1827), 59: (0, 363), 206: (0, 1456), 49: (0, 335), 34: (0, 1589), 212: (0, 1466), 180: (0, 1460), 402: (0, 426), 287: (0, 1471), 200: (0, 1474), 69: (0, 1760), 172: (0, 1481)}, 184: {126: (1, {'@': 1684}), 146: (1, {'@': 1684})}, 185: {60: (1, {'@': 1647}), 126: (1, {'@': 1647}), 222: (1, {'@': 1647}), 220: (1, {'@': 1647}), 36: (1, {'@': 1647}), 221: (1, {'@': 1647}), 223: (1, {'@': 1647}), 57: (1, {'@': 1647})}, 186: {177: (1, {'@': 604}), 7: (1, {'@': 604}), 22: (1, {'@': 604}), 60: (1, {'@': 604}), 126: (1, {'@': 604}), 48: (1, {'@': 604}), 72: (1, {'@': 604}), 178: (1, {'@': 604}), 179: (1, {'@': 604}), 49: (1, {'@': 604}), 57: (1, {'@': 604}), 43: (1, {'@': 604}), 1: (1, {'@': 604}), 2: (1, {'@': 604}), 44: (1, {'@': 604}), 45: (1, {'@': 604}), 47: (1, {'@': 604}), 4: (1, {'@': 604}), 50: (1, {'@': 604}), 51: (1, {'@': 604}), 6: (1, {'@': 604}), 52: (1, {'@': 604}), 8: (1, {'@': 604}), 9: (1, {'@': 604}), 53: (1, {'@': 604}), 11: (1, {'@': 604}), 54: (1, {'@': 604}), 55: (1, {'@': 604}), 15: (1, {'@': 604}), 17: (1, {'@': 604}), 18: (1, {'@': 604}), 58: (1, {'@': 604}), 59: (1, {'@': 604}), 21: (1, {'@': 604}), 61: (1, {'@': 604}), 62: (1, {'@': 604}), 23: (1, {'@': 604}), 25: (1, {'@': 604}), 26: (1, {'@': 604}), 63: (1, {'@': 604}), 27: (1, {'@': 604}), 28: (1, {'@': 604}), 29: (1, {'@': 604}), 30: (1, {'@': 604}), 31: (1, {'@': 604}), 33: (1, {'@': 604}), 64: (1, {'@': 604}), 66: (1, {'@': 604}), 67: (1, {'@': 604}), 34: (1, {'@': 604}), 36: (1, {'@': 604}), 37: (1, {'@': 604}), 68: (1, {'@': 604}), 38: (1, {'@': 604}), 69: (1, {'@': 604}), 70: (1, {'@': 604}), 71: (1, {'@': 604}), 40: (1, {'@': 604}), 41: (1, {'@': 604}), 73: (1, {'@': 604}), 74: (1, {'@': 604}), 75: (1, {'@': 604})}, 187: {60: (0, 894)}, 188: {146: (1, {'@': 1553})}, 189: {126: (0, 2182), 60: (1, {'@': 718})}, 190: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 314: (0, 2451), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 403: (0, 2203), 84: (0, 811), 99: (0, 812), 24: (0, 814), 39: (0, 860), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 86: (0, 471), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 404: (0, 474), 123: (0, 856), 42: (0, 858), 405: (0, 477), 91: (0, 863), 124: (0, 864)}, 191: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 86: (0, 1039), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 192: {146: (1, {'@': 1562})}, 193: {60: (1, {'@': 685})}, 194: {146: (0, 482)}, 195: {146: (1, {'@': 1563})}, 196: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 86: (0, 501), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 303: (0, 525), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 197: {22: (0, 389), 53: (0, 387), 172: (0, 1648), 7: (0, 45), 200: (0, 1652), 59: (0, 363), 49: (0, 335), 198: (0, 1667), 34: (0, 1589), 406: (0, 514), 69: (0, 1760), 212: (0, 1669), 206: (0, 1673), 287: (0, 1676), 180: (0, 1678)}, 198: {230: (1, {'@': 1655}), 60: (1, {'@': 1655}), 235: (1, {'@': 1655}), 240: (1, {'@': 1655}), 126: (1, {'@': 1655}), 231: (1, {'@': 1655}), 234: (1, {'@': 1655}), 57: (1, {'@': 1655}), 241: (1, {'@': 1655}), 243: (1, {'@': 1655})}, 199: {144: (0, 2316), 115: (0, 44), 77: (0, 17), 108: (0, 400), 407: (0, 2216), 109: (0, 390), 92: (0, 1944), 145: (0, 2223), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 86: (0, 2220), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 408: (0, 2237), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 409: (0, 2241), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 200: {167: (0, 1614), 165: (0, 1681), 164: (0, 1694), 27: (0, 408), 51: (0, 1695), 26: (0, 1797), 163: (0, 1698), 38: (0, 1811), 61: (0, 25), 410: (0, 1703), 169: (0, 1708), 37: (0, 1828), 411: (0, 497)}, 201: {230: (1, {'@': 723}), 60: (1, {'@': 723}), 235: (1, {'@': 723}), 240: (1, {'@': 723}), 126: (1, {'@': 723}), 231: (1, {'@': 723}), 234: (1, {'@': 723}), 57: (1, {'@': 723}), 241: (1, {'@': 723}), 243: (1, {'@': 723})}, 202: {156: (0, 43), 159: (0, 42), 412: (0, 1496), 154: (0, 1501), 157: (0, 1505), 153: (0, 41), 152: (0, 1517), 148: (0, 48), 413: (0, 1520), 186: (0, 1525), 149: (0, 1528), 151: (0, 39), 160: (0, 1532), 414: (0, 1538), 158: (0, 1543), 191: (0, 1546), 155: (0, 1549), 150: (0, 1554), 126: (0, 451), 415: (0, 1556), 416: (0, 1560), 147: (0, 28), 187: (0, 1566), 417: (0, 1571), 189: (0, 1575), 418: (0, 459), 419: (0, 1579), 420: (0, 1587), 188: (0, 1592), 190: (0, 1596), 57: (1, {'@': 1256}), 60: (1, {'@': 1256})}, 203: {144: (0, 2316), 145: (0, 2161)}, 204: {230: (1, {'@': 731}), 60: (1, {'@': 731}), 235: (1, {'@': 731}), 240: (1, {'@': 731}), 126: (1, {'@': 731}), 231: (1, {'@': 731}), 234: (1, {'@': 731}), 57: (1, {'@': 731}), 241: (1, {'@': 731}), 243: (1, {'@': 731})}, 205: {60: (1, {'@': 1688}), 147: (1, {'@': 1688}), 154: (1, {'@': 1688}), 148: (1, {'@': 1688}), 126: (1, {'@': 1688}), 149: (1, {'@': 1688}), 155: (1, {'@': 1688}), 151: (1, {'@': 1688}), 152: (1, {'@': 1688}), 150: (1, {'@': 1688}), 156: (1, {'@': 1688}), 157: (1, {'@': 1688}), 158: (1, {'@': 1688}), 159: (1, {'@': 1688}), 153: (1, {'@': 1688}), 57: (1, {'@': 1688}), 160: (1, {'@': 1688})}, 206: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 538), 112: (0, 2376), 97: (0, 2370)}, 207: {156: (0, 43), 159: (0, 42), 412: (0, 1496), 154: (0, 1501), 157: (0, 1505), 153: (0, 41), 152: (0, 1517), 148: (0, 48), 413: (0, 1520), 186: (0, 1525), 149: (0, 1528), 151: (0, 39), 160: (0, 1532), 414: (0, 1538), 158: (0, 1543), 191: (0, 1546), 155: (0, 1549), 150: (0, 1554), 415: (0, 1556), 416: (0, 1560), 147: (0, 28), 187: (0, 1566), 417: (0, 1571), 189: (0, 1575), 419: (0, 1579), 418: (0, 435), 420: (0, 1587), 188: (0, 1592), 190: (0, 1596)}, 208: {144: (0, 544)}, 209: {265: (0, 993), 4: (0, 405), 266: (0, 1016), 267: (0, 1017), 271: (0, 298), 268: (0, 1462), 269: (0, 1465), 67: (0, 1913), 166: (0, 1468), 270: (0, 1470), 30: (0, 1920), 162: (0, 1472), 161: (0, 1476), 272: (0, 1483), 60: (1, {'@': 610}), 57: (1, {'@': 610})}, 210: {146: (1, {'@': 1555})}, 211: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 303: (0, 531), 95: (0, 786), 12: (0, 396), 5: (0, 787), 86: (0, 501), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 212: {146: (1, {'@': 1559})}, 213: {146: (1, {'@': 1556})}, 214: {112: (1, {'@': 1710}), 89: (1, {'@': 1710}), 97: (1, {'@': 1710}), 107: (1, {'@': 1710}), 126: (1, {'@': 1710}), 146: (1, {'@': 1710}), 60: (1, {'@': 1710})}, 215: {146: (1, {'@': 1561})}, 216: {146: (1, {'@': 1557})}, 217: {144: (0, 1025)}, 218: {146: (0, 490)}, 219: {146: (1, {'@': 1558})}, 220: {60: (1, {'@': 1083}), 125: (1, {'@': 1083}), 41: (1, {'@': 1083}), 127: (1, {'@': 1083}), 126: (1, {'@': 1083}), 53: (1, {'@': 1083}), 57: (1, {'@': 1083})}, 221: {146: (1, {'@': 1552})}, 222: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 548)}, 223: {146: (1, {'@': 1554})}, 224: {146: (1, {'@': 1560})}, 225: {144: (0, 2316), 145: (0, 582)}, 226: {60: (1, {'@': 1114}), 57: (1, {'@': 1114})}, 227: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 551), 112: (0, 2376), 97: (0, 2370)}, 228: {22: (0, 389), 206: (0, 1492), 287: (0, 1488), 7: (0, 45), 34: (0, 1589), 180: (0, 1600), 421: (0, 384)}, 229: {60: (1, {'@': 1218}), 7: (1, {'@': 1218}), 22: (1, {'@': 1218}), 126: (1, {'@': 1218}), 174: (1, {'@': 1218}), 175: (1, {'@': 1218}), 49: (1, {'@': 1218}), 57: (1, {'@': 1218}), 176: (1, {'@': 1218})}, 230: {60: (1, {'@': 1250}), 57: (1, {'@': 1250})}, 231: {60: (1, {'@': 1230}), 7: (1, {'@': 1230}), 22: (1, {'@': 1230}), 126: (1, {'@': 1230}), 174: (1, {'@': 1230}), 175: (1, {'@': 1230}), 49: (1, {'@': 1230}), 57: (1, {'@': 1230}), 176: (1, {'@': 1230})}, 232: {144: (0, 541)}, 233: {60: (1, {'@': 1220}), 7: (1, {'@': 1220}), 22: (1, {'@': 1220}), 126: (1, {'@': 1220}), 174: (1, {'@': 1220}), 175: (1, {'@': 1220}), 49: (1, {'@': 1220}), 57: (1, {'@': 1220}), 176: (1, {'@': 1220})}, 234: {115: (0, 44), 77: (0, 17), 108: (0, 400), 86: (0, 2032), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 422: (0, 337), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 423: (0, 881), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 424: (0, 513), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 425: (0, 516), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 235: {7: (0, 45), 27: (0, 408), 180: (0, 1621), 28: (0, 33), 169: (0, 1623), 61: (0, 25), 165: (0, 1626), 37: (0, 1828), 126: (0, 504), 6: (0, 20), 185: (0, 1636), 426: (0, 510), 183: (0, 1638), 164: (0, 1643), 60: (1, {'@': 923}), 57: (1, {'@': 923})}, 236: {107: (0, 558), 427: (0, 576), 144: (0, 580)}, 237: {144: (0, 2316), 145: (0, 586)}, 238: {7: (0, 45), 426: (0, 500), 27: (0, 408), 180: (0, 1621), 28: (0, 33), 169: (0, 1623), 61: (0, 25), 165: (0, 1626), 37: (0, 1828), 6: (0, 20), 185: (0, 1636), 183: (0, 1638), 164: (0, 1643)}, 239: {144: (0, 2316), 145: (0, 554)}, 240: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 86: (0, 592), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 194: (0, 1223), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 428: (0, 593), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 241: {144: (0, 2316), 145: (0, 584)}, 242: {6: (1, {'@': 1668}), 60: (1, {'@': 1668}), 7: (1, {'@': 1668}), 61: (1, {'@': 1668}), 126: (1, {'@': 1668}), 37: (1, {'@': 1668}), 27: (1, {'@': 1668}), 28: (1, {'@': 1668}), 57: (1, {'@': 1668})}, 243: {126: (0, 2164), 146: (1, {'@': 1221})}, 244: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 1258), 112: (0, 2376), 97: (0, 2370)}, 245: {115: (0, 44), 77: (0, 17), 108: (0, 400), 429: (0, 2540), 109: (0, 390), 92: (0, 1944), 430: (0, 556), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 431: (0, 2548), 432: (0, 2552), 96: (0, 789), 82: (0, 791), 98: (0, 793), 433: (0, 2562), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 434: (0, 2565), 435: (0, 2569), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 436: (0, 2573), 437: (0, 2578), 65: (0, 834), 438: (0, 2581), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 86: (0, 2584), 0: (0, 846), 439: (0, 2586), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 440: (0, 2588), 42: (0, 858), 123: (0, 856), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 246: {146: (0, 54)}, 247: {268: (1, {'@': 647}), 60: (1, {'@': 647}), 126: (1, {'@': 647}), 67: (1, {'@': 647}), 270: (1, {'@': 647}), 4: (1, {'@': 647}), 266: (1, {'@': 647}), 30: (1, {'@': 647}), 57: (1, {'@': 647})}, 248: {60: (1, {'@': 991}), 57: (1, {'@': 991})}, 249: {60: (1, {'@': 773}), 57: (1, {'@': 773})}, 250: {60: (0, 571)}, 251: {126: (1, {'@': 810}), 193: (1, {'@': 810}), 57: (1, {'@': 810}), 60: (1, {'@': 810})}, 252: {57: (1, {'@': 791}), 60: (1, {'@': 791})}, 253: {126: (1, {'@': 807}), 193: (1, {'@': 807}), 57: (1, {'@': 807}), 60: (1, {'@': 807})}, 254: {150: (0, 1554), 412: (0, 716)}, 255: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 733)}, 256: {60: (1, {'@': 1232}), 57: (1, {'@': 1232})}, 257: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 86: (0, 572), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 89: (0, 2384), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 194: (0, 575), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 258: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 86: (0, 651), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 259: {60: (0, 797)}, 260: {146: (0, 2147), 60: (0, 564)}, 261: {112: (1, {'@': 1722}), 441: (1, {'@': 1722}), 89: (1, {'@': 1722}), 442: (1, {'@': 1722}), 107: (1, {'@': 1722}), 443: (1, {'@': 1722}), 60: (1, {'@': 1722})}, 262: {60: (1, {'@': 1274})}, 263: {60: (0, 2174)}, 264: {193: (0, 53), 192: (0, 252)}, 265: {112: (1, {'@': 1714}), 89: (1, {'@': 1714}), 97: (1, {'@': 1714}), 107: (1, {'@': 1714}), 126: (1, {'@': 1714}), 146: (1, {'@': 1714}), 60: (1, {'@': 1714})}, 266: {22: (0, 389), 53: (0, 387), 7: (0, 45), 68: (0, 1724), 70: (0, 1727), 444: (0, 1742), 49: (0, 335), 34: (0, 1589), 206: (0, 1747), 198: (0, 1751), 445: (0, 1754), 69: (0, 1760), 172: (0, 1757), 180: (0, 1761), 446: (0, 567), 287: (0, 1764), 200: (0, 1766)}, 267: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 709)}, 268: {112: (1, {'@': 1721}), 441: (1, {'@': 1721}), 89: (1, {'@': 1721}), 442: (1, {'@': 1721}), 107: (1, {'@': 1721}), 443: (1, {'@': 1721}), 60: (1, {'@': 1721})}, 269: {57: (1, {'@': 1184}), 60: (1, {'@': 1184})}, 270: {441: (0, 696)}, 271: {22: (0, 389), 53: (0, 387), 205: (0, 1825), 62: (0, 367), 206: (0, 1838), 447: (0, 596), 172: (0, 1841)}, 272: {57: (1, {'@': 524}), 60: (1, {'@': 524})}, 273: {448: (0, 677), 311: (0, 2072)}, 274: {57: (1, {'@': 792}), 60: (1, {'@': 792})}, 275: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 194: (0, 701), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 276: {443: (0, 673)}, 277: {77: (0, 17), 449: (0, 658), 78: (0, 1960), 79: (0, 1973), 12: (0, 396), 81: (0, 2295), 428: (0, 660), 82: (0, 791), 83: (0, 809), 84: (0, 811), 85: (0, 816), 10: (0, 826), 86: (0, 663), 87: (0, 842), 35: (0, 844), 448: (0, 665), 88: (0, 848), 89: (0, 2384), 90: (0, 853), 91: (0, 863), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 56: (0, 783), 95: (0, 786), 194: (0, 1223), 96: (0, 789), 97: (0, 2370), 98: (0, 793), 19: (0, 800), 13: (0, 802), 32: (0, 807), 99: (0, 812), 100: (0, 817), 20: (0, 822), 102: (0, 823), 103: (0, 825), 105: (0, 830), 65: (0, 834), 106: (0, 838), 107: (0, 2409), 108: (0, 400), 109: (0, 390), 46: (0, 781), 80: (0, 2414), 110: (0, 799), 111: (0, 821), 14: (0, 399), 112: (0, 2376), 113: (0, 828), 114: (0, 832), 0: (0, 846), 42: (0, 858), 39: (0, 860), 115: (0, 44), 116: (0, 780), 311: (0, 2072), 5: (0, 787), 117: (0, 804), 24: (0, 814), 118: (0, 819), 119: (0, 836), 120: (0, 840), 122: (0, 850), 3: (0, 855), 123: (0, 856), 124: (0, 864)}, 278: {60: (0, 687)}, 279: {112: (0, 2001), 450: (0, 1991), 89: (0, 1990), 107: (0, 2029), 442: (0, 1984), 441: (0, 672), 451: (0, 667)}, 280: {57: (1, {'@': 790}), 60: (1, {'@': 790})}, 281: {126: (0, 1810), 146: (1, {'@': 571})}, 282: {443: (0, 569)}, 283: {146: (0, 868)}, 284: {43: (1, {'@': 1501}), 60: (1, {'@': 1501}), 21: (1, {'@': 1501}), 44: (1, {'@': 1501}), 126: (1, {'@': 1501}), 61: (1, {'@': 1501}), 45: (1, {'@': 1501}), 27: (1, {'@': 1501}), 28: (1, {'@': 1501}), 6: (1, {'@': 1501}), 33: (1, {'@': 1501}), 64: (1, {'@': 1501}), 34: (1, {'@': 1501}), 53: (1, {'@': 1501}), 37: (1, {'@': 1501}), 54: (1, {'@': 1501}), 38: (1, {'@': 1501}), 69: (1, {'@': 1501}), 40: (1, {'@': 1501}), 74: (1, {'@': 1501}), 41: (1, {'@': 1501}), 75: (1, {'@': 1501}), 57: (1, {'@': 1501}), 18: (1, {'@': 1501}), 22: (1, {'@': 1501}), 62: (1, {'@': 1501}), 73: (1, {'@': 1501}), 1: (1, {'@': 1501}), 2: (1, {'@': 1501}), 47: (1, {'@': 1501}), 48: (1, {'@': 1501}), 4: (1, {'@': 1501}), 49: (1, {'@': 1501}), 50: (1, {'@': 1501}), 51: (1, {'@': 1501}), 52: (1, {'@': 1501}), 8: (1, {'@': 1501}), 7: (1, {'@': 1501}), 9: (1, {'@': 1501}), 11: (1, {'@': 1501}), 55: (1, {'@': 1501}), 15: (1, {'@': 1501}), 17: (1, {'@': 1501}), 58: (1, {'@': 1501}), 59: (1, {'@': 1501}), 23: (1, {'@': 1501}), 25: (1, {'@': 1501}), 26: (1, {'@': 1501}), 63: (1, {'@': 1501}), 29: (1, {'@': 1501}), 30: (1, {'@': 1501}), 31: (1, {'@': 1501}), 66: (1, {'@': 1501}), 67: (1, {'@': 1501}), 36: (1, {'@': 1501}), 68: (1, {'@': 1501}), 70: (1, {'@': 1501}), 71: (1, {'@': 1501}), 72: (1, {'@': 1501})}, 285: {57: (1, {'@': 522}), 60: (1, {'@': 522})}, 286: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 86: (0, 602), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 194: (0, 1223), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 428: (0, 606), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 120: (0, 840), 106: (0, 838), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 287: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 712), 112: (0, 2376), 97: (0, 2370)}, 288: {192: (0, 590), 193: (0, 53)}, 289: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 86: (0, 646), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 290: {43: (1, {'@': 1504}), 60: (1, {'@': 1504}), 21: (1, {'@': 1504}), 44: (1, {'@': 1504}), 126: (1, {'@': 1504}), 61: (1, {'@': 1504}), 45: (1, {'@': 1504}), 27: (1, {'@': 1504}), 28: (1, {'@': 1504}), 6: (1, {'@': 1504}), 33: (1, {'@': 1504}), 64: (1, {'@': 1504}), 34: (1, {'@': 1504}), 53: (1, {'@': 1504}), 37: (1, {'@': 1504}), 54: (1, {'@': 1504}), 38: (1, {'@': 1504}), 69: (1, {'@': 1504}), 40: (1, {'@': 1504}), 74: (1, {'@': 1504}), 41: (1, {'@': 1504}), 75: (1, {'@': 1504}), 57: (1, {'@': 1504}), 18: (1, {'@': 1504}), 22: (1, {'@': 1504}), 62: (1, {'@': 1504}), 73: (1, {'@': 1504}), 1: (1, {'@': 1504}), 2: (1, {'@': 1504}), 47: (1, {'@': 1504}), 48: (1, {'@': 1504}), 4: (1, {'@': 1504}), 49: (1, {'@': 1504}), 50: (1, {'@': 1504}), 51: (1, {'@': 1504}), 52: (1, {'@': 1504}), 8: (1, {'@': 1504}), 7: (1, {'@': 1504}), 9: (1, {'@': 1504}), 11: (1, {'@': 1504}), 55: (1, {'@': 1504}), 15: (1, {'@': 1504}), 17: (1, {'@': 1504}), 58: (1, {'@': 1504}), 59: (1, {'@': 1504}), 23: (1, {'@': 1504}), 25: (1, {'@': 1504}), 26: (1, {'@': 1504}), 63: (1, {'@': 1504}), 29: (1, {'@': 1504}), 30: (1, {'@': 1504}), 31: (1, {'@': 1504}), 66: (1, {'@': 1504}), 67: (1, {'@': 1504}), 36: (1, {'@': 1504}), 68: (1, {'@': 1504}), 70: (1, {'@': 1504}), 71: (1, {'@': 1504}), 72: (1, {'@': 1504})}, 291: {112: (1, {'@': 1717}), 441: (1, {'@': 1717}), 89: (1, {'@': 1717}), 442: (1, {'@': 1717}), 107: (1, {'@': 1717}), 443: (1, {'@': 1717}), 60: (1, {'@': 1717})}, 292: {60: (1, {'@': 775}), 57: (1, {'@': 775})}, 293: {112: (0, 2001), 450: (0, 1991), 89: (0, 1990), 443: (0, 664), 107: (0, 2029), 442: (0, 1984), 451: (0, 661)}, 294: {452: (0, 1821), 453: (0, 589)}, 295: {454: (0, 188), 455: (0, 210), 456: (0, 212), 457: (0, 213), 458: (0, 215), 459: (0, 216), 460: (0, 218), 461: (0, 219), 144: (0, 221), 462: (0, 223), 463: (0, 224)}, 296: {146: (0, 299)}, 297: {78: (0, 52), 32: (0, 61), 96: (0, 63), 119: (0, 64), 315: (0, 66), 316: (0, 67), 317: (0, 68), 318: (0, 69), 99: (0, 70), 91: (0, 71), 19: (0, 72), 319: (0, 74), 320: (0, 75), 321: (0, 76), 322: (0, 77), 323: (0, 78), 16: (0, 79), 13: (0, 80), 118: (0, 81), 115: (0, 86), 105: (0, 87), 324: (0, 89), 325: (0, 90), 122: (0, 91), 85: (0, 93), 39: (0, 95), 259: (0, 97), 326: (0, 99), 327: (0, 100), 114: (0, 101), 328: (0, 103), 124: (0, 104), 84: (0, 105), 102: (0, 106), 3: (0, 107), 113: (0, 109), 65: (0, 110), 90: (0, 112), 94: (0, 113), 329: (0, 115), 95: (0, 116), 330: (0, 117), 331: (0, 118), 0: (0, 119), 110: (0, 1461), 332: (0, 1464), 46: (0, 1467), 333: (0, 1475), 93: (0, 1477), 24: (0, 1485), 111: (0, 1493), 120: (0, 1499), 98: (0, 1503), 117: (0, 1504), 56: (0, 1511), 334: (0, 1514), 14: (0, 1515), 5: (0, 1526), 335: (0, 1533), 108: (0, 1536), 336: (0, 1539), 20: (0, 1541), 337: (0, 1547), 79: (0, 1550), 10: (0, 1552), 338: (0, 1559), 77: (0, 1563), 339: (0, 1564), 340: (0, 1568), 83: (0, 1570), 103: (0, 1572), 341: (0, 1586), 342: (0, 1588), 123: (0, 1591), 344: (0, 1593), 345: (0, 1595), 346: (0, 1597), 347: (0, 1599), 348: (0, 1601), 82: (0, 1605), 349: (0, 1613), 350: (0, 1615), 100: (0, 1618), 116: (0, 1630), 343: (0, 1633), 106: (0, 1634), 351: (0, 1645), 352: (0, 1647), 353: (0, 1649), 354: (0, 1651), 88: (0, 1653), 355: (0, 1662), 356: (0, 1663), 35: (0, 1664), 92: (0, 1672), 357: (0, 1682), 12: (0, 1684), 87: (0, 1692), 358: (0, 1700), 359: (0, 1702), 360: (0, 1705), 361: (0, 1707), 362: (0, 1709), 42: (0, 1712), 363: (0, 1720), 364: (0, 1722), 365: (0, 1725), 366: (0, 1726), 109: (0, 1729), 367: (0, 1735), 368: (0, 1738), 369: (0, 1740), 370: (0, 1744), 371: (0, 1745), 372: (0, 1748), 373: (0, 1749)}, 298: {60: (1, {'@': 609}), 57: (1, {'@': 609})}, 299: {464: (0, 1982), 465: (0, 1996), 466: (0, 656)}, 300: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 1863)}, 301: {4: (0, 405), 7: (0, 45), 161: (0, 413), 27: (0, 408), 215: (0, 1790), 50: (0, 1792), 26: (0, 1797), 467: (0, 2576), 180: (0, 1807), 38: (0, 1811), 183: (0, 1813), 167: (0, 1817), 28: (0, 33), 61: (0, 25), 214: (0, 2583), 47: (0, 1820), 164: (0, 1824), 37: (0, 1828), 126: (0, 2585), 45: (0, 1833), 169: (0, 1836), 163: (0, 1842), 165: (0, 1846), 6: (0, 20), 185: (0, 1849), 168: (0, 1853), 217: (0, 1857), 57: (1, {'@': 938}), 60: (1, {'@': 938})}, 302: {112: (1, {'@': 1712}), 89: (1, {'@': 1712}), 97: (1, {'@': 1712}), 107: (1, {'@': 1712}), 126: (1, {'@': 1712}), 146: (1, {'@': 1712}), 60: (1, {'@': 1712})}, 303: {44: (1, {'@': 1096}), 49: (1, {'@': 1096}), 6: (1, {'@': 1096}), 7: (1, {'@': 1096}), 53: (1, {'@': 1096}), 57: (1, {'@': 1096}), 59: (1, {'@': 1096}), 60: (1, {'@': 1096}), 21: (1, {'@': 1096}), 22: (1, {'@': 1096}), 126: (1, {'@': 1096}), 62: (1, {'@': 1096}), 61: (1, {'@': 1096}), 23: (1, {'@': 1096}), 25: (1, {'@': 1096}), 28: (1, {'@': 1096}), 33: (1, {'@': 1096}), 69: (1, {'@': 1096}), 40: (1, {'@': 1096}), 41: (1, {'@': 1096}), 75: (1, {'@': 1096}), 73: (1, {'@': 1096})}, 304: {44: (1, {'@': 1090}), 49: (1, {'@': 1090}), 6: (1, {'@': 1090}), 7: (1, {'@': 1090}), 53: (1, {'@': 1090}), 57: (1, {'@': 1090}), 59: (1, {'@': 1090}), 60: (1, {'@': 1090}), 21: (1, {'@': 1090}), 22: (1, {'@': 1090}), 126: (1, {'@': 1090}), 62: (1, {'@': 1090}), 61: (1, {'@': 1090}), 23: (1, {'@': 1090}), 25: (1, {'@': 1090}), 28: (1, {'@': 1090}), 33: (1, {'@': 1090}), 69: (1, {'@': 1090}), 40: (1, {'@': 1090}), 41: (1, {'@': 1090}), 75: (1, {'@': 1090}), 73: (1, {'@': 1090})}, 305: {57: (1, {'@': 783}), 60: (1, {'@': 783})}, 306: {306: (0, 1770), 305: (0, 132), 126: (0, 131), 374: (0, 140), 375: (0, 143), 468: (0, 145), 57: (1, {'@': 554}), 60: (1, {'@': 554})}, 307: {268: (1, {'@': 1641}), 60: (1, {'@': 1641}), 126: (1, {'@': 1641}), 67: (1, {'@': 1641}), 270: (1, {'@': 1641}), 4: (1, {'@': 1641}), 266: (1, {'@': 1641}), 30: (1, {'@': 1641}), 57: (1, {'@': 1641})}, 308: {57: (1, {'@': 781}), 60: (1, {'@': 781})}, 309: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 260), 112: (0, 2376), 97: (0, 2370)}, 310: {112: (0, 2001), 450: (0, 1991), 89: (0, 1990), 107: (0, 2029), 442: (0, 1984), 60: (0, 659), 451: (0, 653)}, 311: {57: (1, {'@': 1243}), 60: (1, {'@': 1243}), 126: (1, {'@': 1243}), 6: (1, {'@': 1243}), 469: (1, {'@': 1243})}, 312: {57: (1, {'@': 1065}), 60: (1, {'@': 1065})}, 313: {144: (0, 57)}, 314: {441: (0, 679)}, 315: {293: (1, {'@': 751}), 60: (1, {'@': 751}), 52: (1, {'@': 751}), 8: (1, {'@': 751}), 126: (1, {'@': 751}), 57: (1, {'@': 751}), 2: (1, {'@': 751}), 44: (1, {'@': 751}), 61: (1, {'@': 751}), 63: (1, {'@': 751}), 28: (1, {'@': 751}), 33: (1, {'@': 751}), 6: (1, {'@': 751}), 53: (1, {'@': 751}), 37: (1, {'@': 751}), 71: (1, {'@': 751}), 55: (1, {'@': 751}), 43: (1, {'@': 751}), 1: (1, {'@': 751}), 45: (1, {'@': 751}), 47: (1, {'@': 751}), 48: (1, {'@': 751}), 4: (1, {'@': 751}), 49: (1, {'@': 751}), 50: (1, {'@': 751}), 51: (1, {'@': 751}), 7: (1, {'@': 751}), 9: (1, {'@': 751}), 11: (1, {'@': 751}), 54: (1, {'@': 751}), 15: (1, {'@': 751}), 17: (1, {'@': 751}), 18: (1, {'@': 751}), 58: (1, {'@': 751}), 59: (1, {'@': 751}), 21: (1, {'@': 751}), 22: (1, {'@': 751}), 62: (1, {'@': 751}), 23: (1, {'@': 751}), 25: (1, {'@': 751}), 26: (1, {'@': 751}), 27: (1, {'@': 751}), 29: (1, {'@': 751}), 30: (1, {'@': 751}), 31: (1, {'@': 751}), 64: (1, {'@': 751}), 66: (1, {'@': 751}), 67: (1, {'@': 751}), 34: (1, {'@': 751}), 36: (1, {'@': 751}), 68: (1, {'@': 751}), 38: (1, {'@': 751}), 69: (1, {'@': 751}), 70: (1, {'@': 751}), 40: (1, {'@': 751}), 72: (1, {'@': 751}), 41: (1, {'@': 751}), 73: (1, {'@': 751}), 74: (1, {'@': 751}), 75: (1, {'@': 751})}, 316: {60: (0, 329), 126: (0, 1328)}, 317: {146: (0, 1441)}, 318: {80: (0, 2414), 194: (0, 594), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 319: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 631)}, 320: {44: (1, {'@': 1104}), 49: (1, {'@': 1104}), 6: (1, {'@': 1104}), 7: (1, {'@': 1104}), 53: (1, {'@': 1104}), 57: (1, {'@': 1104}), 59: (1, {'@': 1104}), 60: (1, {'@': 1104}), 21: (1, {'@': 1104}), 22: (1, {'@': 1104}), 126: (1, {'@': 1104}), 62: (1, {'@': 1104}), 61: (1, {'@': 1104}), 23: (1, {'@': 1104}), 25: (1, {'@': 1104}), 28: (1, {'@': 1104}), 33: (1, {'@': 1104}), 69: (1, {'@': 1104}), 40: (1, {'@': 1104}), 41: (1, {'@': 1104}), 75: (1, {'@': 1104}), 73: (1, {'@': 1104})}, 321: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 194: (0, 652), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 86: (0, 650), 42: (0, 858), 123: (0, 856), 39: (0, 860), 124: (0, 864)}, 322: {43: (1, {'@': 1052}), 60: (1, {'@': 1052}), 21: (1, {'@': 1052}), 44: (1, {'@': 1052}), 126: (1, {'@': 1052}), 61: (1, {'@': 1052}), 45: (1, {'@': 1052}), 27: (1, {'@': 1052}), 28: (1, {'@': 1052}), 6: (1, {'@': 1052}), 33: (1, {'@': 1052}), 64: (1, {'@': 1052}), 34: (1, {'@': 1052}), 53: (1, {'@': 1052}), 37: (1, {'@': 1052}), 54: (1, {'@': 1052}), 38: (1, {'@': 1052}), 69: (1, {'@': 1052}), 40: (1, {'@': 1052}), 74: (1, {'@': 1052}), 41: (1, {'@': 1052}), 75: (1, {'@': 1052}), 57: (1, {'@': 1052}), 18: (1, {'@': 1052}), 1: (1, {'@': 1052}), 2: (1, {'@': 1052}), 47: (1, {'@': 1052}), 48: (1, {'@': 1052}), 4: (1, {'@': 1052}), 49: (1, {'@': 1052}), 50: (1, {'@': 1052}), 51: (1, {'@': 1052}), 52: (1, {'@': 1052}), 8: (1, {'@': 1052}), 7: (1, {'@': 1052}), 9: (1, {'@': 1052}), 11: (1, {'@': 1052}), 55: (1, {'@': 1052}), 15: (1, {'@': 1052}), 17: (1, {'@': 1052}), 58: (1, {'@': 1052}), 59: (1, {'@': 1052}), 22: (1, {'@': 1052}), 62: (1, {'@': 1052}), 23: (1, {'@': 1052}), 25: (1, {'@': 1052}), 26: (1, {'@': 1052}), 63: (1, {'@': 1052}), 29: (1, {'@': 1052}), 30: (1, {'@': 1052}), 31: (1, {'@': 1052}), 66: (1, {'@': 1052}), 67: (1, {'@': 1052}), 36: (1, {'@': 1052}), 68: (1, {'@': 1052}), 70: (1, {'@': 1052}), 71: (1, {'@': 1052}), 72: (1, {'@': 1052}), 73: (1, {'@': 1052})}, 323: {470: (0, 1862), 471: (0, 622)}, 324: {44: (1, {'@': 1089}), 49: (1, {'@': 1089}), 6: (1, {'@': 1089}), 7: (1, {'@': 1089}), 53: (1, {'@': 1089}), 57: (1, {'@': 1089}), 59: (1, {'@': 1089}), 60: (1, {'@': 1089}), 21: (1, {'@': 1089}), 22: (1, {'@': 1089}), 126: (1, {'@': 1089}), 62: (1, {'@': 1089}), 61: (1, {'@': 1089}), 23: (1, {'@': 1089}), 25: (1, {'@': 1089}), 28: (1, {'@': 1089}), 33: (1, {'@': 1089}), 69: (1, {'@': 1089}), 40: (1, {'@': 1089}), 41: (1, {'@': 1089}), 75: (1, {'@': 1089}), 73: (1, {'@': 1089})}, 325: {112: (1, {'@': 1706}), 89: (1, {'@': 1706}), 97: (1, {'@': 1706}), 107: (1, {'@': 1706}), 126: (1, {'@': 1706}), 146: (1, {'@': 1706}), 60: (1, {'@': 1706})}, 326: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 472: (0, 2418), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 86: (0, 655), 473: (0, 668), 474: (0, 671), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 475: (0, 675), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 327: {112: (0, 2491)}, 328: {144: (0, 2316), 145: (0, 638)}, 329: {1: (1, {'@': 987}), 6: (1, {'@': 987}), 60: (1, {'@': 987}), 61: (1, {'@': 987}), 126: (1, {'@': 987}), 45: (1, {'@': 987}), 38: (1, {'@': 987}), 26: (1, {'@': 987}), 27: (1, {'@': 987}), 28: (1, {'@': 987}), 57: (1, {'@': 987}), 43: (1, {'@': 987}), 2: (1, {'@': 987}), 44: (1, {'@': 987}), 47: (1, {'@': 987}), 48: (1, {'@': 987}), 4: (1, {'@': 987}), 49: (1, {'@': 987}), 50: (1, {'@': 987}), 51: (1, {'@': 987}), 52: (1, {'@': 987}), 8: (1, {'@': 987}), 7: (1, {'@': 987}), 9: (1, {'@': 987}), 53: (1, {'@': 987}), 11: (1, {'@': 987}), 54: (1, {'@': 987}), 55: (1, {'@': 987}), 15: (1, {'@': 987}), 17: (1, {'@': 987}), 18: (1, {'@': 987}), 58: (1, {'@': 987}), 59: (1, {'@': 987}), 21: (1, {'@': 987}), 22: (1, {'@': 987}), 62: (1, {'@': 987}), 23: (1, {'@': 987}), 25: (1, {'@': 987}), 63: (1, {'@': 987}), 29: (1, {'@': 987}), 30: (1, {'@': 987}), 31: (1, {'@': 987}), 33: (1, {'@': 987}), 64: (1, {'@': 987}), 66: (1, {'@': 987}), 67: (1, {'@': 987}), 34: (1, {'@': 987}), 36: (1, {'@': 987}), 37: (1, {'@': 987}), 68: (1, {'@': 987}), 69: (1, {'@': 987}), 70: (1, {'@': 987}), 71: (1, {'@': 987}), 40: (1, {'@': 987}), 72: (1, {'@': 987}), 41: (1, {'@': 987}), 73: (1, {'@': 987}), 74: (1, {'@': 987}), 75: (1, {'@': 987})}, 330: {44: (1, {'@': 1091}), 49: (1, {'@': 1091}), 6: (1, {'@': 1091}), 7: (1, {'@': 1091}), 53: (1, {'@': 1091}), 57: (1, {'@': 1091}), 59: (1, {'@': 1091}), 60: (1, {'@': 1091}), 21: (1, {'@': 1091}), 22: (1, {'@': 1091}), 126: (1, {'@': 1091}), 62: (1, {'@': 1091}), 61: (1, {'@': 1091}), 23: (1, {'@': 1091}), 25: (1, {'@': 1091}), 28: (1, {'@': 1091}), 33: (1, {'@': 1091}), 69: (1, {'@': 1091}), 40: (1, {'@': 1091}), 41: (1, {'@': 1091}), 75: (1, {'@': 1091}), 73: (1, {'@': 1091})}, 331: {60: (1, {'@': 686})}, 332: {144: (0, 2316), 145: (0, 648)}, 333: {22: (0, 389), 53: (0, 387), 18: (0, 1581), 172: (0, 1872), 33: (0, 383), 64: (0, 1537), 200: (0, 1876), 44: (0, 358), 126: (0, 635), 183: (0, 1880), 62: (0, 367), 21: (0, 366), 164: (0, 1883), 287: (0, 1886), 204: (0, 1889), 75: (0, 341), 34: (0, 1589), 28: (0, 33), 61: (0, 25), 208: (0, 1904), 205: (0, 1907), 207: (0, 1912), 280: (0, 1916), 213: (0, 1919), 54: (0, 1598), 283: (0, 1922), 40: (0, 1756), 69: (0, 1760), 185: (0, 1932), 211: (0, 1936), 210: (0, 1941), 206: (0, 1946), 73: (0, 1763), 6: (0, 20), 476: (0, 639), 286: (0, 1951), 57: (1, {'@': 1006}), 60: (1, {'@': 1006})}, 334: {44: (1, {'@': 1088}), 49: (1, {'@': 1088}), 6: (1, {'@': 1088}), 7: (1, {'@': 1088}), 53: (1, {'@': 1088}), 57: (1, {'@': 1088}), 59: (1, {'@': 1088}), 60: (1, {'@': 1088}), 21: (1, {'@': 1088}), 22: (1, {'@': 1088}), 126: (1, {'@': 1088}), 62: (1, {'@': 1088}), 61: (1, {'@': 1088}), 23: (1, {'@': 1088}), 25: (1, {'@': 1088}), 28: (1, {'@': 1088}), 33: (1, {'@': 1088}), 69: (1, {'@': 1088}), 40: (1, {'@': 1088}), 41: (1, {'@': 1088}), 75: (1, {'@': 1088}), 73: (1, {'@': 1088})}, 335: {112: (0, 2493)}, 336: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 194: (0, 682), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 337: {60: (1, {'@': 1003})}, 338: {60: (1, {'@': 1678}), 21: (1, {'@': 1678}), 22: (1, {'@': 1678}), 44: (1, {'@': 1678}), 126: (1, {'@': 1678}), 62: (1, {'@': 1678}), 61: (1, {'@': 1678}), 28: (1, {'@': 1678}), 33: (1, {'@': 1678}), 6: (1, {'@': 1678}), 64: (1, {'@': 1678}), 34: (1, {'@': 1678}), 53: (1, {'@': 1678}), 54: (1, {'@': 1678}), 69: (1, {'@': 1678}), 40: (1, {'@': 1678}), 73: (1, {'@': 1678}), 75: (1, {'@': 1678}), 57: (1, {'@': 1678}), 18: (1, {'@': 1678})}, 339: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 618), 112: (0, 2376), 97: (0, 2370)}, 340: {22: (0, 389), 53: (0, 387), 18: (0, 1581), 172: (0, 1872), 33: (0, 383), 64: (0, 1537), 200: (0, 1876), 44: (0, 358), 476: (0, 633), 183: (0, 1880), 62: (0, 367), 21: (0, 366), 164: (0, 1883), 287: (0, 1886), 204: (0, 1889), 75: (0, 341), 34: (0, 1589), 28: (0, 33), 61: (0, 25), 208: (0, 1904), 205: (0, 1907), 207: (0, 1912), 280: (0, 1916), 213: (0, 1919), 54: (0, 1598), 283: (0, 1922), 40: (0, 1756), 69: (0, 1760), 185: (0, 1932), 211: (0, 1936), 210: (0, 1941), 206: (0, 1946), 73: (0, 1763), 6: (0, 20), 286: (0, 1951)}, 341: {112: (0, 2495)}, 342: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 607), 112: (0, 2376), 97: (0, 2370)}, 343: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 627)}, 344: {60: (0, 177)}, 345: {60: (1, {'@': 1346}), 57: (1, {'@': 1346})}, 346: {112: (1, {'@': 1719}), 441: (1, {'@': 1719}), 89: (1, {'@': 1719}), 442: (1, {'@': 1719}), 107: (1, {'@': 1719}), 443: (1, {'@': 1719}), 60: (1, {'@': 1719})}, 347: {44: (1, {'@': 1102}), 49: (1, {'@': 1102}), 6: (1, {'@': 1102}), 7: (1, {'@': 1102}), 53: (1, {'@': 1102}), 57: (1, {'@': 1102}), 59: (1, {'@': 1102}), 60: (1, {'@': 1102}), 21: (1, {'@': 1102}), 22: (1, {'@': 1102}), 126: (1, {'@': 1102}), 62: (1, {'@': 1102}), 61: (1, {'@': 1102}), 23: (1, {'@': 1102}), 25: (1, {'@': 1102}), 28: (1, {'@': 1102}), 33: (1, {'@': 1102}), 69: (1, {'@': 1102}), 40: (1, {'@': 1102}), 41: (1, {'@': 1102}), 75: (1, {'@': 1102}), 73: (1, {'@': 1102})}, 348: {112: (1, {'@': 1702}), 89: (1, {'@': 1702}), 97: (1, {'@': 1702}), 107: (1, {'@': 1702}), 126: (1, {'@': 1702}), 146: (1, {'@': 1702}), 60: (1, {'@': 1702})}, 349: {144: (0, 2316), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 86: (0, 689), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 145: (0, 681), 124: (0, 864)}, 350: {44: (1, {'@': 1105}), 49: (1, {'@': 1105}), 6: (1, {'@': 1105}), 7: (1, {'@': 1105}), 53: (1, {'@': 1105}), 57: (1, {'@': 1105}), 59: (1, {'@': 1105}), 60: (1, {'@': 1105}), 21: (1, {'@': 1105}), 22: (1, {'@': 1105}), 126: (1, {'@': 1105}), 62: (1, {'@': 1105}), 61: (1, {'@': 1105}), 23: (1, {'@': 1105}), 25: (1, {'@': 1105}), 28: (1, {'@': 1105}), 33: (1, {'@': 1105}), 69: (1, {'@': 1105}), 40: (1, {'@': 1105}), 41: (1, {'@': 1105}), 75: (1, {'@': 1105}), 73: (1, {'@': 1105})}, 351: {44: (1, {'@': 1094}), 49: (1, {'@': 1094}), 6: (1, {'@': 1094}), 7: (1, {'@': 1094}), 53: (1, {'@': 1094}), 57: (1, {'@': 1094}), 59: (1, {'@': 1094}), 60: (1, {'@': 1094}), 21: (1, {'@': 1094}), 22: (1, {'@': 1094}), 126: (1, {'@': 1094}), 62: (1, {'@': 1094}), 61: (1, {'@': 1094}), 23: (1, {'@': 1094}), 25: (1, {'@': 1094}), 28: (1, {'@': 1094}), 33: (1, {'@': 1094}), 69: (1, {'@': 1094}), 40: (1, {'@': 1094}), 41: (1, {'@': 1094}), 75: (1, {'@': 1094}), 73: (1, {'@': 1094})}, 352: {60: (0, 1529)}, 353: {144: (0, 2316), 145: (0, 703)}, 354: {44: (1, {'@': 1099}), 49: (1, {'@': 1099}), 6: (1, {'@': 1099}), 7: (1, {'@': 1099}), 53: (1, {'@': 1099}), 57: (1, {'@': 1099}), 59: (1, {'@': 1099}), 60: (1, {'@': 1099}), 21: (1, {'@': 1099}), 22: (1, {'@': 1099}), 126: (1, {'@': 1099}), 62: (1, {'@': 1099}), 61: (1, {'@': 1099}), 23: (1, {'@': 1099}), 25: (1, {'@': 1099}), 28: (1, {'@': 1099}), 33: (1, {'@': 1099}), 69: (1, {'@': 1099}), 40: (1, {'@': 1099}), 41: (1, {'@': 1099}), 75: (1, {'@': 1099}), 73: (1, {'@': 1099})}, 355: {60: (0, 738)}, 356: {80: (0, 2414), 194: (0, 662), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 357: {185: (0, 311), 469: (0, 2282), 477: (0, 714), 6: (0, 20), 478: (0, 2296)}, 358: {112: (0, 2478)}, 359: {44: (1, {'@': 1100}), 49: (1, {'@': 1100}), 6: (1, {'@': 1100}), 7: (1, {'@': 1100}), 53: (1, {'@': 1100}), 57: (1, {'@': 1100}), 59: (1, {'@': 1100}), 60: (1, {'@': 1100}), 21: (1, {'@': 1100}), 22: (1, {'@': 1100}), 126: (1, {'@': 1100}), 62: (1, {'@': 1100}), 61: (1, {'@': 1100}), 23: (1, {'@': 1100}), 25: (1, {'@': 1100}), 28: (1, {'@': 1100}), 33: (1, {'@': 1100}), 69: (1, {'@': 1100}), 40: (1, {'@': 1100}), 41: (1, {'@': 1100}), 75: (1, {'@': 1100}), 73: (1, {'@': 1100})}, 360: {400: (0, 1799), 401: (0, 684)}, 361: {43: (1, {'@': 1486}), 60: (1, {'@': 1486}), 21: (1, {'@': 1486}), 44: (1, {'@': 1486}), 126: (1, {'@': 1486}), 61: (1, {'@': 1486}), 45: (1, {'@': 1486}), 27: (1, {'@': 1486}), 28: (1, {'@': 1486}), 6: (1, {'@': 1486}), 33: (1, {'@': 1486}), 64: (1, {'@': 1486}), 34: (1, {'@': 1486}), 53: (1, {'@': 1486}), 37: (1, {'@': 1486}), 54: (1, {'@': 1486}), 38: (1, {'@': 1486}), 69: (1, {'@': 1486}), 40: (1, {'@': 1486}), 74: (1, {'@': 1486}), 41: (1, {'@': 1486}), 75: (1, {'@': 1486}), 57: (1, {'@': 1486}), 18: (1, {'@': 1486}), 22: (1, {'@': 1486}), 62: (1, {'@': 1486}), 73: (1, {'@': 1486}), 1: (1, {'@': 1486}), 2: (1, {'@': 1486}), 47: (1, {'@': 1486}), 48: (1, {'@': 1486}), 4: (1, {'@': 1486}), 49: (1, {'@': 1486}), 50: (1, {'@': 1486}), 51: (1, {'@': 1486}), 52: (1, {'@': 1486}), 8: (1, {'@': 1486}), 7: (1, {'@': 1486}), 9: (1, {'@': 1486}), 11: (1, {'@': 1486}), 55: (1, {'@': 1486}), 15: (1, {'@': 1486}), 17: (1, {'@': 1486}), 58: (1, {'@': 1486}), 59: (1, {'@': 1486}), 23: (1, {'@': 1486}), 25: (1, {'@': 1486}), 26: (1, {'@': 1486}), 63: (1, {'@': 1486}), 29: (1, {'@': 1486}), 30: (1, {'@': 1486}), 31: (1, {'@': 1486}), 66: (1, {'@': 1486}), 67: (1, {'@': 1486}), 36: (1, {'@': 1486}), 68: (1, {'@': 1486}), 70: (1, {'@': 1486}), 71: (1, {'@': 1486}), 72: (1, {'@': 1486})}, 362: {60: (0, 724)}, 363: {112: (0, 2504)}, 364: {43: (1, {'@': 1058}), 60: (1, {'@': 1058}), 21: (1, {'@': 1058}), 44: (1, {'@': 1058}), 126: (1, {'@': 1058}), 61: (1, {'@': 1058}), 45: (1, {'@': 1058}), 27: (1, {'@': 1058}), 28: (1, {'@': 1058}), 6: (1, {'@': 1058}), 33: (1, {'@': 1058}), 64: (1, {'@': 1058}), 34: (1, {'@': 1058}), 53: (1, {'@': 1058}), 37: (1, {'@': 1058}), 54: (1, {'@': 1058}), 38: (1, {'@': 1058}), 69: (1, {'@': 1058}), 40: (1, {'@': 1058}), 74: (1, {'@': 1058}), 41: (1, {'@': 1058}), 75: (1, {'@': 1058}), 57: (1, {'@': 1058}), 18: (1, {'@': 1058}), 1: (1, {'@': 1058}), 2: (1, {'@': 1058}), 47: (1, {'@': 1058}), 48: (1, {'@': 1058}), 4: (1, {'@': 1058}), 49: (1, {'@': 1058}), 50: (1, {'@': 1058}), 51: (1, {'@': 1058}), 52: (1, {'@': 1058}), 8: (1, {'@': 1058}), 7: (1, {'@': 1058}), 9: (1, {'@': 1058}), 11: (1, {'@': 1058}), 55: (1, {'@': 1058}), 15: (1, {'@': 1058}), 17: (1, {'@': 1058}), 58: (1, {'@': 1058}), 59: (1, {'@': 1058}), 22: (1, {'@': 1058}), 62: (1, {'@': 1058}), 23: (1, {'@': 1058}), 25: (1, {'@': 1058}), 26: (1, {'@': 1058}), 63: (1, {'@': 1058}), 29: (1, {'@': 1058}), 30: (1, {'@': 1058}), 31: (1, {'@': 1058}), 66: (1, {'@': 1058}), 67: (1, {'@': 1058}), 36: (1, {'@': 1058}), 68: (1, {'@': 1058}), 70: (1, {'@': 1058}), 71: (1, {'@': 1058}), 72: (1, {'@': 1058}), 73: (1, {'@': 1058})}, 365: {204: (0, 1972), 165: (0, 2211), 479: (0, 2215), 53: (0, 387), 33: (0, 383), 63: (0, 2218), 164: (0, 2221), 44: (0, 358), 2: (0, 2225), 480: (0, 697), 55: (0, 2229), 185: (0, 2239), 481: (0, 2240), 8: (0, 1510), 52: (0, 1498), 28: (0, 33), 210: (0, 2244), 61: (0, 25), 482: (0, 2248), 483: (0, 2251), 290: (0, 2257), 37: (0, 1828), 71: (0, 2263), 6: (0, 20), 126: (0, 700), 183: (0, 2267), 292: (0, 2274), 172: (0, 2278), 57: (1, {'@': 814}), 60: (1, {'@': 814})}, 366: {112: (0, 96), 59: (1, {'@': 1509}), 60: (1, {'@': 1509}), 21: (1, {'@': 1509}), 22: (1, {'@': 1509}), 44: (1, {'@': 1509}), 126: (1, {'@': 1509}), 62: (1, {'@': 1509}), 61: (1, {'@': 1509}), 23: (1, {'@': 1509}), 25: (1, {'@': 1509}), 28: (1, {'@': 1509}), 49: (1, {'@': 1509}), 6: (1, {'@': 1509}), 33: (1, {'@': 1509}), 7: (1, {'@': 1509}), 53: (1, {'@': 1509}), 69: (1, {'@': 1509}), 40: (1, {'@': 1509}), 41: (1, {'@': 1509}), 75: (1, {'@': 1509}), 73: (1, {'@': 1509}), 57: (1, {'@': 1509}), 43: (1, {'@': 1509}), 45: (1, {'@': 1509}), 27: (1, {'@': 1509}), 64: (1, {'@': 1509}), 34: (1, {'@': 1509}), 37: (1, {'@': 1509}), 54: (1, {'@': 1509}), 38: (1, {'@': 1509}), 74: (1, {'@': 1509}), 18: (1, {'@': 1509}), 1: (1, {'@': 1509}), 2: (1, {'@': 1509}), 47: (1, {'@': 1509}), 48: (1, {'@': 1509}), 4: (1, {'@': 1509}), 50: (1, {'@': 1509}), 51: (1, {'@': 1509}), 52: (1, {'@': 1509}), 8: (1, {'@': 1509}), 9: (1, {'@': 1509}), 11: (1, {'@': 1509}), 55: (1, {'@': 1509}), 15: (1, {'@': 1509}), 17: (1, {'@': 1509}), 58: (1, {'@': 1509}), 26: (1, {'@': 1509}), 63: (1, {'@': 1509}), 29: (1, {'@': 1509}), 30: (1, {'@': 1509}), 31: (1, {'@': 1509}), 66: (1, {'@': 1509}), 67: (1, {'@': 1509}), 36: (1, {'@': 1509}), 68: (1, {'@': 1509}), 70: (1, {'@': 1509}), 71: (1, {'@': 1509}), 72: (1, {'@': 1509})}, 367: {112: (0, 94)}, 368: {146: (0, 208)}, 369: {33: (1, {'@': 866}), 58: (1, {'@': 866}), 6: (1, {'@': 866}), 60: (1, {'@': 866}), 44: (1, {'@': 866}), 66: (1, {'@': 866}), 53: (1, {'@': 866}), 126: (1, {'@': 866}), 37: (1, {'@': 866}), 28: (1, {'@': 866}), 57: (1, {'@': 866}), 43: (1, {'@': 866}), 1: (1, {'@': 866}), 2: (1, {'@': 866}), 45: (1, {'@': 866}), 47: (1, {'@': 866}), 48: (1, {'@': 866}), 4: (1, {'@': 866}), 49: (1, {'@': 866}), 50: (1, {'@': 866}), 51: (1, {'@': 866}), 52: (1, {'@': 866}), 8: (1, {'@': 866}), 7: (1, {'@': 866}), 9: (1, {'@': 866}), 11: (1, {'@': 866}), 54: (1, {'@': 866}), 55: (1, {'@': 866}), 15: (1, {'@': 866}), 17: (1, {'@': 866}), 18: (1, {'@': 866}), 59: (1, {'@': 866}), 21: (1, {'@': 866}), 22: (1, {'@': 866}), 61: (1, {'@': 866}), 62: (1, {'@': 866}), 23: (1, {'@': 866}), 25: (1, {'@': 866}), 26: (1, {'@': 866}), 63: (1, {'@': 866}), 27: (1, {'@': 866}), 29: (1, {'@': 866}), 30: (1, {'@': 866}), 31: (1, {'@': 866}), 64: (1, {'@': 866}), 67: (1, {'@': 866}), 34: (1, {'@': 866}), 36: (1, {'@': 866}), 68: (1, {'@': 866}), 38: (1, {'@': 866}), 69: (1, {'@': 866}), 70: (1, {'@': 866}), 71: (1, {'@': 866}), 40: (1, {'@': 866}), 72: (1, {'@': 866}), 41: (1, {'@': 866}), 73: (1, {'@': 866}), 74: (1, {'@': 866}), 75: (1, {'@': 866})}, 370: {43: (1, {'@': 1481}), 60: (1, {'@': 1481}), 21: (1, {'@': 1481}), 44: (1, {'@': 1481}), 126: (1, {'@': 1481}), 61: (1, {'@': 1481}), 45: (1, {'@': 1481}), 27: (1, {'@': 1481}), 28: (1, {'@': 1481}), 6: (1, {'@': 1481}), 33: (1, {'@': 1481}), 64: (1, {'@': 1481}), 34: (1, {'@': 1481}), 53: (1, {'@': 1481}), 37: (1, {'@': 1481}), 54: (1, {'@': 1481}), 38: (1, {'@': 1481}), 69: (1, {'@': 1481}), 40: (1, {'@': 1481}), 74: (1, {'@': 1481}), 41: (1, {'@': 1481}), 75: (1, {'@': 1481}), 57: (1, {'@': 1481}), 18: (1, {'@': 1481}), 22: (1, {'@': 1481}), 62: (1, {'@': 1481}), 73: (1, {'@': 1481}), 1: (1, {'@': 1481}), 2: (1, {'@': 1481}), 47: (1, {'@': 1481}), 48: (1, {'@': 1481}), 4: (1, {'@': 1481}), 49: (1, {'@': 1481}), 50: (1, {'@': 1481}), 51: (1, {'@': 1481}), 52: (1, {'@': 1481}), 8: (1, {'@': 1481}), 7: (1, {'@': 1481}), 9: (1, {'@': 1481}), 11: (1, {'@': 1481}), 55: (1, {'@': 1481}), 15: (1, {'@': 1481}), 17: (1, {'@': 1481}), 58: (1, {'@': 1481}), 59: (1, {'@': 1481}), 23: (1, {'@': 1481}), 25: (1, {'@': 1481}), 26: (1, {'@': 1481}), 63: (1, {'@': 1481}), 29: (1, {'@': 1481}), 30: (1, {'@': 1481}), 31: (1, {'@': 1481}), 66: (1, {'@': 1481}), 67: (1, {'@': 1481}), 36: (1, {'@': 1481}), 68: (1, {'@': 1481}), 70: (1, {'@': 1481}), 71: (1, {'@': 1481}), 72: (1, {'@': 1481})}, 371: {33: (1, {'@': 1660}), 2: (1, {'@': 1660}), 6: (1, {'@': 1660}), 52: (1, {'@': 1660}), 8: (1, {'@': 1660}), 44: (1, {'@': 1660}), 61: (1, {'@': 1660}), 53: (1, {'@': 1660}), 126: (1, {'@': 1660}), 60: (1, {'@': 1660}), 37: (1, {'@': 1660}), 71: (1, {'@': 1660}), 63: (1, {'@': 1660}), 55: (1, {'@': 1660}), 28: (1, {'@': 1660}), 57: (1, {'@': 1660})}, 372: {112: (0, 1583), 59: (1, {'@': 1512}), 60: (1, {'@': 1512}), 21: (1, {'@': 1512}), 22: (1, {'@': 1512}), 44: (1, {'@': 1512}), 126: (1, {'@': 1512}), 62: (1, {'@': 1512}), 61: (1, {'@': 1512}), 23: (1, {'@': 1512}), 25: (1, {'@': 1512}), 28: (1, {'@': 1512}), 49: (1, {'@': 1512}), 6: (1, {'@': 1512}), 33: (1, {'@': 1512}), 7: (1, {'@': 1512}), 53: (1, {'@': 1512}), 69: (1, {'@': 1512}), 40: (1, {'@': 1512}), 41: (1, {'@': 1512}), 75: (1, {'@': 1512}), 73: (1, {'@': 1512}), 57: (1, {'@': 1512}), 125: (1, {'@': 1512}), 127: (1, {'@': 1512}), 43: (1, {'@': 1512}), 45: (1, {'@': 1512}), 27: (1, {'@': 1512}), 64: (1, {'@': 1512}), 34: (1, {'@': 1512}), 37: (1, {'@': 1512}), 54: (1, {'@': 1512}), 38: (1, {'@': 1512}), 74: (1, {'@': 1512}), 18: (1, {'@': 1512}), 1: (1, {'@': 1512}), 2: (1, {'@': 1512}), 47: (1, {'@': 1512}), 48: (1, {'@': 1512}), 4: (1, {'@': 1512}), 50: (1, {'@': 1512}), 51: (1, {'@': 1512}), 52: (1, {'@': 1512}), 8: (1, {'@': 1512}), 9: (1, {'@': 1512}), 11: (1, {'@': 1512}), 55: (1, {'@': 1512}), 15: (1, {'@': 1512}), 17: (1, {'@': 1512}), 58: (1, {'@': 1512}), 26: (1, {'@': 1512}), 63: (1, {'@': 1512}), 29: (1, {'@': 1512}), 30: (1, {'@': 1512}), 31: (1, {'@': 1512}), 66: (1, {'@': 1512}), 67: (1, {'@': 1512}), 36: (1, {'@': 1512}), 68: (1, {'@': 1512}), 70: (1, {'@': 1512}), 71: (1, {'@': 1512}), 72: (1, {'@': 1512})}, 373: {204: (0, 1972), 165: (0, 2211), 479: (0, 2215), 53: (0, 387), 33: (0, 383), 63: (0, 2218), 480: (0, 678), 164: (0, 2221), 44: (0, 358), 2: (0, 2225), 55: (0, 2229), 185: (0, 2239), 481: (0, 2240), 8: (0, 1510), 52: (0, 1498), 28: (0, 33), 210: (0, 2244), 61: (0, 25), 482: (0, 2248), 483: (0, 2251), 290: (0, 2257), 37: (0, 1828), 71: (0, 2263), 6: (0, 20), 183: (0, 2267), 292: (0, 2274), 172: (0, 2278)}, 374: {448: (0, 691), 311: (0, 2072)}, 375: {115: (0, 44), 77: (0, 17), 108: (0, 400), 194: (0, 2512), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 86: (0, 2516), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 376: {43: (1, {'@': 1613}), 1: (1, {'@': 1613}), 2: (1, {'@': 1613}), 44: (1, {'@': 1613}), 45: (1, {'@': 1613}), 47: (1, {'@': 1613}), 48: (1, {'@': 1613}), 4: (1, {'@': 1613}), 49: (1, {'@': 1613}), 50: (1, {'@': 1613}), 51: (1, {'@': 1613}), 6: (1, {'@': 1613}), 52: (1, {'@': 1613}), 8: (1, {'@': 1613}), 7: (1, {'@': 1613}), 9: (1, {'@': 1613}), 53: (1, {'@': 1613}), 11: (1, {'@': 1613}), 54: (1, {'@': 1613}), 55: (1, {'@': 1613}), 15: (1, {'@': 1613}), 17: (1, {'@': 1613}), 57: (1, {'@': 1613}), 18: (1, {'@': 1613}), 58: (1, {'@': 1613}), 59: (1, {'@': 1613}), 21: (1, {'@': 1613}), 22: (1, {'@': 1613}), 60: (1, {'@': 1613}), 61: (1, {'@': 1613}), 126: (1, {'@': 1613}), 62: (1, {'@': 1613}), 23: (1, {'@': 1613}), 25: (1, {'@': 1613}), 26: (1, {'@': 1613}), 63: (1, {'@': 1613}), 27: (1, {'@': 1613}), 28: (1, {'@': 1613}), 29: (1, {'@': 1613}), 30: (1, {'@': 1613}), 31: (1, {'@': 1613}), 33: (1, {'@': 1613}), 64: (1, {'@': 1613}), 66: (1, {'@': 1613}), 67: (1, {'@': 1613}), 34: (1, {'@': 1613}), 36: (1, {'@': 1613}), 37: (1, {'@': 1613}), 68: (1, {'@': 1613}), 38: (1, {'@': 1613}), 69: (1, {'@': 1613}), 70: (1, {'@': 1613}), 71: (1, {'@': 1613}), 40: (1, {'@': 1613}), 72: (1, {'@': 1613}), 41: (1, {'@': 1613}), 73: (1, {'@': 1613}), 74: (1, {'@': 1613}), 75: (1, {'@': 1613})}, 377: {126: (0, 1224)}, 378: {60: (1, {'@': 1416})}, 379: {198: (0, 393), 22: (0, 389), 53: (0, 387), 33: (0, 383), 7: (0, 45), 44: (0, 358), 41: (0, 372), 62: (0, 367), 21: (0, 366), 59: (0, 363), 200: (0, 395), 180: (0, 359), 201: (0, 354), 183: (0, 351), 202: (0, 350), 164: (0, 347), 75: (0, 341), 126: (0, 2521), 203: (0, 402), 204: (0, 304), 49: (0, 335), 205: (0, 334), 28: (0, 33), 206: (0, 330), 61: (0, 25), 23: (0, 327), 185: (0, 324), 207: (0, 320), 208: (0, 303), 40: (0, 1756), 69: (0, 1760), 73: (0, 1763), 172: (0, 1765), 210: (0, 1769), 211: (0, 1774), 6: (0, 20), 199: (0, 2529), 212: (0, 1778), 25: (0, 1783), 213: (0, 1788), 57: (1, {'@': 1087}), 60: (1, {'@': 1087})}, 380: {193: (0, 53), 192: (0, 686)}, 381: {296: (0, 2462), 58: (0, 1666), 48: (0, 1843), 29: (0, 1870), 63: (0, 2218), 64: (0, 1537), 53: (0, 387), 41: (0, 372), 70: (0, 1727), 50: (0, 1792), 26: (0, 1797), 484: (0, 2472), 8: (0, 1510), 38: (0, 1811), 183: (0, 2473), 49: (0, 335), 295: (0, 2475), 43: (0, 1548), 61: (0, 25), 165: (0, 2477), 1: (0, 1793), 69: (0, 1760), 67: (0, 1913), 45: (0, 1833), 30: (0, 1920), 51: (0, 1695), 71: (0, 2263), 206: (0, 2479), 52: (0, 1498), 6: (0, 20), 44: (0, 358), 203: (0, 2481), 280: (0, 2482), 40: (0, 1756), 15: (0, 1909), 33: (0, 383), 213: (0, 2484), 18: (0, 1581), 7: (0, 45), 445: (0, 2485), 66: (0, 1679), 21: (0, 366), 2: (0, 2225), 55: (0, 2229), 217: (0, 2487), 166: (0, 2489), 59: (0, 363), 182: (0, 2490), 212: (0, 2492), 34: (0, 1589), 284: (0, 2496), 28: (0, 33), 36: (0, 15), 54: (0, 1598), 164: (0, 2498), 72: (0, 1882), 286: (0, 2500), 31: (0, 1901), 17: (0, 50), 37: (0, 1828), 211: (0, 2501), 73: (0, 1763), 23: (0, 327), 22: (0, 389), 68: (0, 1724), 198: (0, 2505), 210: (0, 2507), 74: (0, 1616), 483: (0, 2508), 309: (0, 2510), 27: (0, 408), 392: (0, 2511), 180: (0, 2513), 292: (0, 2515), 398: (0, 2517), 287: (0, 2518), 485: (0, 718), 4: (0, 405), 200: (0, 2519), 11: (0, 84), 162: (0, 2522), 47: (0, 1820), 172: (0, 2524), 197: (0, 2526), 410: (0, 2528), 202: (0, 2530), 9: (0, 1906), 290: (0, 2532), 204: (0, 2534), 205: (0, 2537), 167: (0, 2539), 215: (0, 2541), 163: (0, 2543), 207: (0, 2545), 62: (0, 367), 185: (0, 2546), 170: (0, 2550), 75: (0, 341), 168: (0, 2551), 395: (0, 2553), 396: (0, 2554), 444: (0, 2556), 161: (0, 2558), 208: (0, 2560), 481: (0, 2561), 173: (0, 2564), 283: (0, 2567), 169: (0, 2568), 25: (0, 1783), 479: (0, 2571), 482: (0, 2572), 201: (0, 2575), 281: (0, 2577)}, 382: {60: (1, {'@': 1241}), 57: (1, {'@': 1241})}, 383: {112: (0, 2470)}, 384: {60: (1, {'@': 1249}), 57: (1, {'@': 1249})}, 385: {76: (0, 2146), 107: (0, 2409), 112: (0, 2376), 81: (0, 2295), 80: (0, 2149), 97: (0, 2370), 89: (0, 2384), 121: (0, 2154), 101: (0, 643)}, 386: {81: (0, 2295), 76: (0, 720), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 80: (0, 2149)}, 387: {112: (0, 2435)}, 388: {43: (1, {'@': 1616}), 1: (1, {'@': 1616}), 2: (1, {'@': 1616}), 44: (1, {'@': 1616}), 45: (1, {'@': 1616}), 47: (1, {'@': 1616}), 48: (1, {'@': 1616}), 4: (1, {'@': 1616}), 49: (1, {'@': 1616}), 50: (1, {'@': 1616}), 51: (1, {'@': 1616}), 6: (1, {'@': 1616}), 52: (1, {'@': 1616}), 8: (1, {'@': 1616}), 7: (1, {'@': 1616}), 9: (1, {'@': 1616}), 53: (1, {'@': 1616}), 11: (1, {'@': 1616}), 54: (1, {'@': 1616}), 55: (1, {'@': 1616}), 15: (1, {'@': 1616}), 17: (1, {'@': 1616}), 57: (1, {'@': 1616}), 18: (1, {'@': 1616}), 58: (1, {'@': 1616}), 59: (1, {'@': 1616}), 21: (1, {'@': 1616}), 22: (1, {'@': 1616}), 60: (1, {'@': 1616}), 61: (1, {'@': 1616}), 126: (1, {'@': 1616}), 62: (1, {'@': 1616}), 23: (1, {'@': 1616}), 25: (1, {'@': 1616}), 26: (1, {'@': 1616}), 63: (1, {'@': 1616}), 27: (1, {'@': 1616}), 28: (1, {'@': 1616}), 29: (1, {'@': 1616}), 30: (1, {'@': 1616}), 31: (1, {'@': 1616}), 33: (1, {'@': 1616}), 64: (1, {'@': 1616}), 66: (1, {'@': 1616}), 67: (1, {'@': 1616}), 34: (1, {'@': 1616}), 36: (1, {'@': 1616}), 37: (1, {'@': 1616}), 68: (1, {'@': 1616}), 38: (1, {'@': 1616}), 69: (1, {'@': 1616}), 70: (1, {'@': 1616}), 71: (1, {'@': 1616}), 40: (1, {'@': 1616}), 72: (1, {'@': 1616}), 41: (1, {'@': 1616}), 73: (1, {'@': 1616}), 74: (1, {'@': 1616}), 75: (1, {'@': 1616})}, 389: {112: (0, 2450)}, 390: {126: (1, {'@': 409}), 146: (1, {'@': 409}), 60: (1, {'@': 409})}, 391: {126: (1, {'@': 393}), 146: (1, {'@': 393}), 60: (1, {'@': 393})}, 392: {293: (1, {'@': 747}), 60: (1, {'@': 747}), 52: (1, {'@': 747}), 8: (1, {'@': 747}), 126: (1, {'@': 747}), 57: (1, {'@': 747})}, 393: {44: (1, {'@': 1093}), 49: (1, {'@': 1093}), 6: (1, {'@': 1093}), 7: (1, {'@': 1093}), 53: (1, {'@': 1093}), 57: (1, {'@': 1093}), 59: (1, {'@': 1093}), 60: (1, {'@': 1093}), 21: (1, {'@': 1093}), 22: (1, {'@': 1093}), 126: (1, {'@': 1093}), 62: (1, {'@': 1093}), 61: (1, {'@': 1093}), 23: (1, {'@': 1093}), 25: (1, {'@': 1093}), 28: (1, {'@': 1093}), 33: (1, {'@': 1093}), 69: (1, {'@': 1093}), 40: (1, {'@': 1093}), 41: (1, {'@': 1093}), 75: (1, {'@': 1093}), 73: (1, {'@': 1093})}, 394: {146: (0, 711)}, 395: {44: (1, {'@': 1101}), 49: (1, {'@': 1101}), 6: (1, {'@': 1101}), 7: (1, {'@': 1101}), 53: (1, {'@': 1101}), 57: (1, {'@': 1101}), 59: (1, {'@': 1101}), 60: (1, {'@': 1101}), 21: (1, {'@': 1101}), 22: (1, {'@': 1101}), 126: (1, {'@': 1101}), 62: (1, {'@': 1101}), 61: (1, {'@': 1101}), 23: (1, {'@': 1101}), 25: (1, {'@': 1101}), 28: (1, {'@': 1101}), 33: (1, {'@': 1101}), 69: (1, {'@': 1101}), 40: (1, {'@': 1101}), 41: (1, {'@': 1101}), 75: (1, {'@': 1101}), 73: (1, {'@': 1101})}, 396: {126: (1, {'@': 383}), 146: (1, {'@': 383}), 60: (1, {'@': 383})}, 397: {80: (0, 2414), 81: (0, 2295), 194: (0, 597), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 398: {60: (0, 583)}, 399: {126: (1, {'@': 389}), 146: (1, {'@': 389}), 60: (1, {'@': 389})}, 400: {126: (1, {'@': 390}), 146: (1, {'@': 390}), 60: (1, {'@': 390})}, 401: {80: (0, 2414), 194: (0, 604), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 486: (0, 706)}, 402: {44: (1, {'@': 1106}), 49: (1, {'@': 1106}), 6: (1, {'@': 1106}), 7: (1, {'@': 1106}), 53: (1, {'@': 1106}), 57: (1, {'@': 1106}), 59: (1, {'@': 1106}), 60: (1, {'@': 1106}), 21: (1, {'@': 1106}), 22: (1, {'@': 1106}), 126: (1, {'@': 1106}), 62: (1, {'@': 1106}), 61: (1, {'@': 1106}), 23: (1, {'@': 1106}), 25: (1, {'@': 1106}), 28: (1, {'@': 1106}), 33: (1, {'@': 1106}), 69: (1, {'@': 1106}), 40: (1, {'@': 1106}), 41: (1, {'@': 1106}), 75: (1, {'@': 1106}), 73: (1, {'@': 1106})}, 403: {60: (0, 717)}, 404: {146: (0, 721)}, 405: {112: (0, 2547)}, 406: {60: (0, 2136)}, 407: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 194: (0, 612), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 408: {112: (0, 199)}, 409: {146: (0, 727)}, 410: {146: (0, 244)}, 411: {293: (1, {'@': 753}), 60: (1, {'@': 753}), 52: (1, {'@': 753}), 8: (1, {'@': 753}), 126: (1, {'@': 753}), 57: (1, {'@': 753}), 2: (1, {'@': 753}), 44: (1, {'@': 753}), 61: (1, {'@': 753}), 63: (1, {'@': 753}), 28: (1, {'@': 753}), 33: (1, {'@': 753}), 6: (1, {'@': 753}), 53: (1, {'@': 753}), 37: (1, {'@': 753}), 71: (1, {'@': 753}), 55: (1, {'@': 753}), 43: (1, {'@': 753}), 1: (1, {'@': 753}), 45: (1, {'@': 753}), 47: (1, {'@': 753}), 48: (1, {'@': 753}), 4: (1, {'@': 753}), 49: (1, {'@': 753}), 50: (1, {'@': 753}), 51: (1, {'@': 753}), 7: (1, {'@': 753}), 9: (1, {'@': 753}), 11: (1, {'@': 753}), 54: (1, {'@': 753}), 15: (1, {'@': 753}), 17: (1, {'@': 753}), 18: (1, {'@': 753}), 58: (1, {'@': 753}), 59: (1, {'@': 753}), 21: (1, {'@': 753}), 22: (1, {'@': 753}), 62: (1, {'@': 753}), 23: (1, {'@': 753}), 25: (1, {'@': 753}), 26: (1, {'@': 753}), 27: (1, {'@': 753}), 29: (1, {'@': 753}), 30: (1, {'@': 753}), 31: (1, {'@': 753}), 64: (1, {'@': 753}), 66: (1, {'@': 753}), 67: (1, {'@': 753}), 34: (1, {'@': 753}), 36: (1, {'@': 753}), 68: (1, {'@': 753}), 38: (1, {'@': 753}), 69: (1, {'@': 753}), 70: (1, {'@': 753}), 40: (1, {'@': 753}), 72: (1, {'@': 753}), 41: (1, {'@': 753}), 73: (1, {'@': 753}), 74: (1, {'@': 753}), 75: (1, {'@': 753})}, 412: {60: (0, 708)}, 413: {6: (1, {'@': 944}), 60: (1, {'@': 944}), 7: (1, {'@': 944}), 61: (1, {'@': 944}), 126: (1, {'@': 944}), 45: (1, {'@': 944}), 37: (1, {'@': 944}), 38: (1, {'@': 944}), 47: (1, {'@': 944}), 26: (1, {'@': 944}), 27: (1, {'@': 944}), 4: (1, {'@': 944}), 28: (1, {'@': 944}), 50: (1, {'@': 944}), 57: (1, {'@': 944})}, 414: {487: (0, 2082), 488: (0, 640), 489: (0, 2074)}, 415: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 86: (0, 1622), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 416: {60: (0, 1416)}, 417: {146: (0, 2424)}, 418: {60: (0, 1375)}, 419: {313: (0, 2377), 312: (0, 1629)}, 420: {60: (0, 2093)}, 421: {146: (1, {'@': 891})}, 422: {146: (0, 2088)}, 423: {126: (1, {'@': 1572}), 60: (1, {'@': 1572})}, 424: {60: (0, 2083)}, 425: {60: (0, 1432)}, 426: {60: (1, {'@': 1125}), 57: (1, {'@': 1125})}, 427: {60: (0, 1434)}, 428: {57: (1, {'@': 639}), 60: (1, {'@': 639}), 61: (1, {'@': 639}), 53: (1, {'@': 639}), 67: (1, {'@': 639}), 126: (1, {'@': 639}), 37: (1, {'@': 639}), 45: (1, {'@': 639}), 38: (1, {'@': 639}), 26: (1, {'@': 639}), 27: (1, {'@': 639}), 4: (1, {'@': 639}), 29: (1, {'@': 639}), 30: (1, {'@': 639}), 15: (1, {'@': 639}), 268: (1, {'@': 639}), 270: (1, {'@': 639}), 266: (1, {'@': 639}), 43: (1, {'@': 639}), 1: (1, {'@': 639}), 2: (1, {'@': 639}), 44: (1, {'@': 639}), 47: (1, {'@': 639}), 48: (1, {'@': 639}), 49: (1, {'@': 639}), 50: (1, {'@': 639}), 51: (1, {'@': 639}), 6: (1, {'@': 639}), 52: (1, {'@': 639}), 8: (1, {'@': 639}), 7: (1, {'@': 639}), 9: (1, {'@': 639}), 11: (1, {'@': 639}), 54: (1, {'@': 639}), 55: (1, {'@': 639}), 17: (1, {'@': 639}), 18: (1, {'@': 639}), 58: (1, {'@': 639}), 59: (1, {'@': 639}), 21: (1, {'@': 639}), 22: (1, {'@': 639}), 62: (1, {'@': 639}), 23: (1, {'@': 639}), 25: (1, {'@': 639}), 63: (1, {'@': 639}), 28: (1, {'@': 639}), 31: (1, {'@': 639}), 33: (1, {'@': 639}), 64: (1, {'@': 639}), 66: (1, {'@': 639}), 34: (1, {'@': 639}), 36: (1, {'@': 639}), 68: (1, {'@': 639}), 69: (1, {'@': 639}), 70: (1, {'@': 639}), 71: (1, {'@': 639}), 40: (1, {'@': 639}), 72: (1, {'@': 639}), 41: (1, {'@': 639}), 73: (1, {'@': 639}), 74: (1, {'@': 639}), 75: (1, {'@': 639})}, 429: {60: (0, 1426)}, 430: {60: (0, 2081)}, 431: {107: (0, 558), 427: (0, 1670), 144: (0, 580)}, 432: {60: (0, 1429)}, 433: {146: (0, 2080)}, 434: {60: (0, 1438)}, 435: {60: (1, {'@': 1687}), 147: (1, {'@': 1687}), 154: (1, {'@': 1687}), 148: (1, {'@': 1687}), 126: (1, {'@': 1687}), 149: (1, {'@': 1687}), 155: (1, {'@': 1687}), 151: (1, {'@': 1687}), 152: (1, {'@': 1687}), 150: (1, {'@': 1687}), 156: (1, {'@': 1687}), 157: (1, {'@': 1687}), 158: (1, {'@': 1687}), 159: (1, {'@': 1687}), 153: (1, {'@': 1687}), 57: (1, {'@': 1687}), 160: (1, {'@': 1687})}, 436: {490: (0, 2317), 77: (0, 17), 115: (0, 44), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 491: (0, 1443), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 492: (0, 2347), 79: (0, 1973), 116: (0, 780), 493: (0, 2351), 46: (0, 781), 494: (0, 2334), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 86: (0, 2341), 24: (0, 814), 495: (0, 2354), 85: (0, 816), 111: (0, 821), 20: (0, 822), 102: (0, 823), 496: (0, 2343), 103: (0, 825), 14: (0, 399), 118: (0, 819), 10: (0, 826), 100: (0, 817), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 437: {57: (1, {'@': 884}), 60: (1, {'@': 884}), 61: (1, {'@': 884}), 53: (1, {'@': 884}), 67: (1, {'@': 884}), 126: (1, {'@': 884}), 37: (1, {'@': 884}), 45: (1, {'@': 884}), 38: (1, {'@': 884}), 26: (1, {'@': 884}), 27: (1, {'@': 884}), 4: (1, {'@': 884}), 29: (1, {'@': 884}), 30: (1, {'@': 884}), 15: (1, {'@': 884}), 43: (1, {'@': 884}), 1: (1, {'@': 884}), 2: (1, {'@': 884}), 44: (1, {'@': 884}), 47: (1, {'@': 884}), 48: (1, {'@': 884}), 49: (1, {'@': 884}), 50: (1, {'@': 884}), 51: (1, {'@': 884}), 6: (1, {'@': 884}), 52: (1, {'@': 884}), 8: (1, {'@': 884}), 7: (1, {'@': 884}), 9: (1, {'@': 884}), 11: (1, {'@': 884}), 54: (1, {'@': 884}), 55: (1, {'@': 884}), 17: (1, {'@': 884}), 18: (1, {'@': 884}), 58: (1, {'@': 884}), 59: (1, {'@': 884}), 21: (1, {'@': 884}), 22: (1, {'@': 884}), 62: (1, {'@': 884}), 23: (1, {'@': 884}), 25: (1, {'@': 884}), 63: (1, {'@': 884}), 28: (1, {'@': 884}), 31: (1, {'@': 884}), 33: (1, {'@': 884}), 64: (1, {'@': 884}), 66: (1, {'@': 884}), 34: (1, {'@': 884}), 36: (1, {'@': 884}), 68: (1, {'@': 884}), 69: (1, {'@': 884}), 70: (1, {'@': 884}), 71: (1, {'@': 884}), 40: (1, {'@': 884}), 72: (1, {'@': 884}), 41: (1, {'@': 884}), 73: (1, {'@': 884}), 74: (1, {'@': 884}), 75: (1, {'@': 884})}, 438: {60: (0, 2062)}, 439: {57: (1, {'@': 894}), 60: (1, {'@': 894}), 61: (1, {'@': 894}), 53: (1, {'@': 894}), 67: (1, {'@': 894}), 126: (1, {'@': 894}), 37: (1, {'@': 894}), 45: (1, {'@': 894}), 38: (1, {'@': 894}), 26: (1, {'@': 894}), 27: (1, {'@': 894}), 4: (1, {'@': 894}), 29: (1, {'@': 894}), 30: (1, {'@': 894}), 15: (1, {'@': 894}), 43: (1, {'@': 894}), 1: (1, {'@': 894}), 2: (1, {'@': 894}), 44: (1, {'@': 894}), 47: (1, {'@': 894}), 48: (1, {'@': 894}), 49: (1, {'@': 894}), 50: (1, {'@': 894}), 51: (1, {'@': 894}), 6: (1, {'@': 894}), 52: (1, {'@': 894}), 8: (1, {'@': 894}), 7: (1, {'@': 894}), 9: (1, {'@': 894}), 11: (1, {'@': 894}), 54: (1, {'@': 894}), 55: (1, {'@': 894}), 17: (1, {'@': 894}), 18: (1, {'@': 894}), 58: (1, {'@': 894}), 59: (1, {'@': 894}), 21: (1, {'@': 894}), 22: (1, {'@': 894}), 62: (1, {'@': 894}), 23: (1, {'@': 894}), 25: (1, {'@': 894}), 63: (1, {'@': 894}), 28: (1, {'@': 894}), 31: (1, {'@': 894}), 33: (1, {'@': 894}), 64: (1, {'@': 894}), 66: (1, {'@': 894}), 34: (1, {'@': 894}), 36: (1, {'@': 894}), 68: (1, {'@': 894}), 69: (1, {'@': 894}), 70: (1, {'@': 894}), 71: (1, {'@': 894}), 40: (1, {'@': 894}), 72: (1, {'@': 894}), 41: (1, {'@': 894}), 73: (1, {'@': 894}), 74: (1, {'@': 894}), 75: (1, {'@': 894})}, 440: {126: (0, 674), 60: (1, {'@': 1170})}, 441: {57: (1, {'@': 621}), 60: (1, {'@': 621}), 61: (1, {'@': 621}), 53: (1, {'@': 621}), 67: (1, {'@': 621}), 126: (1, {'@': 621}), 37: (1, {'@': 621}), 45: (1, {'@': 621}), 38: (1, {'@': 621}), 26: (1, {'@': 621}), 27: (1, {'@': 621}), 4: (1, {'@': 621}), 29: (1, {'@': 621}), 30: (1, {'@': 621}), 15: (1, {'@': 621}), 268: (1, {'@': 621}), 270: (1, {'@': 621}), 266: (1, {'@': 621}), 43: (1, {'@': 621}), 1: (1, {'@': 621}), 2: (1, {'@': 621}), 44: (1, {'@': 621}), 47: (1, {'@': 621}), 48: (1, {'@': 621}), 49: (1, {'@': 621}), 50: (1, {'@': 621}), 51: (1, {'@': 621}), 6: (1, {'@': 621}), 52: (1, {'@': 621}), 8: (1, {'@': 621}), 7: (1, {'@': 621}), 9: (1, {'@': 621}), 11: (1, {'@': 621}), 54: (1, {'@': 621}), 55: (1, {'@': 621}), 17: (1, {'@': 621}), 18: (1, {'@': 621}), 58: (1, {'@': 621}), 59: (1, {'@': 621}), 21: (1, {'@': 621}), 22: (1, {'@': 621}), 62: (1, {'@': 621}), 23: (1, {'@': 621}), 25: (1, {'@': 621}), 63: (1, {'@': 621}), 28: (1, {'@': 621}), 31: (1, {'@': 621}), 33: (1, {'@': 621}), 64: (1, {'@': 621}), 66: (1, {'@': 621}), 34: (1, {'@': 621}), 36: (1, {'@': 621}), 68: (1, {'@': 621}), 69: (1, {'@': 621}), 70: (1, {'@': 621}), 71: (1, {'@': 621}), 40: (1, {'@': 621}), 72: (1, {'@': 621}), 41: (1, {'@': 621}), 73: (1, {'@': 621}), 74: (1, {'@': 621}), 75: (1, {'@': 621})}, 442: {60: (0, 2059)}, 443: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 86: (0, 1632), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 444: {126: (1, {'@': 1695})}, 445: {57: (1, {'@': 1246}), 60: (1, {'@': 1246}), 126: (1, {'@': 1246}), 6: (1, {'@': 1246}), 469: (1, {'@': 1246})}, 446: {146: (0, 2058)}, 447: {60: (0, 1140)}, 448: {60: (1, {'@': 658}), 126: (1, {'@': 658}), 222: (1, {'@': 658}), 220: (1, {'@': 658}), 36: (1, {'@': 658}), 221: (1, {'@': 658}), 223: (1, {'@': 658}), 57: (1, {'@': 658})}, 449: {146: (0, 2096)}, 450: {60: (1, {'@': 668}), 126: (1, {'@': 668}), 222: (1, {'@': 668}), 220: (1, {'@': 668}), 36: (1, {'@': 668}), 221: (1, {'@': 668}), 223: (1, {'@': 668}), 57: (1, {'@': 668})}, 451: {156: (0, 43), 159: (0, 42), 412: (0, 1496), 154: (0, 1501), 157: (0, 1505), 153: (0, 41), 152: (0, 1517), 148: (0, 48), 413: (0, 1520), 186: (0, 1525), 149: (0, 1528), 151: (0, 39), 418: (0, 2052), 160: (0, 1532), 414: (0, 1538), 158: (0, 1543), 191: (0, 1546), 155: (0, 1549), 150: (0, 1554), 415: (0, 1556), 416: (0, 1560), 147: (0, 28), 187: (0, 1566), 417: (0, 1571), 189: (0, 1575), 419: (0, 1579), 420: (0, 1587), 188: (0, 1592), 190: (0, 1596)}, 452: {146: (0, 1453)}, 453: {60: (1, {'@': 665}), 126: (1, {'@': 665}), 222: (1, {'@': 665}), 220: (1, {'@': 665}), 36: (1, {'@': 665}), 221: (1, {'@': 665}), 223: (1, {'@': 665}), 57: (1, {'@': 665})}, 454: {126: (0, 1450)}, 455: {60: (1, {'@': 670}), 126: (1, {'@': 670}), 222: (1, {'@': 670}), 220: (1, {'@': 670}), 36: (1, {'@': 670}), 221: (1, {'@': 670}), 223: (1, {'@': 670}), 57: (1, {'@': 670})}, 456: {57: (1, {'@': 1462}), 60: (1, {'@': 1462}), 6: (1, {'@': 1462}), 7: (1, {'@': 1462}), 61: (1, {'@': 1462}), 126: (1, {'@': 1462}), 45: (1, {'@': 1462}), 37: (1, {'@': 1462}), 38: (1, {'@': 1462}), 47: (1, {'@': 1462}), 26: (1, {'@': 1462}), 27: (1, {'@': 1462}), 4: (1, {'@': 1462}), 28: (1, {'@': 1462}), 50: (1, {'@': 1462}), 53: (1, {'@': 1462}), 67: (1, {'@': 1462}), 29: (1, {'@': 1462}), 30: (1, {'@': 1462}), 15: (1, {'@': 1462}), 43: (1, {'@': 1462}), 21: (1, {'@': 1462}), 44: (1, {'@': 1462}), 33: (1, {'@': 1462}), 64: (1, {'@': 1462}), 34: (1, {'@': 1462}), 54: (1, {'@': 1462}), 69: (1, {'@': 1462}), 40: (1, {'@': 1462}), 74: (1, {'@': 1462}), 41: (1, {'@': 1462}), 75: (1, {'@': 1462}), 18: (1, {'@': 1462}), 1: (1, {'@': 1462}), 2: (1, {'@': 1462}), 48: (1, {'@': 1462}), 49: (1, {'@': 1462}), 51: (1, {'@': 1462}), 52: (1, {'@': 1462}), 8: (1, {'@': 1462}), 9: (1, {'@': 1462}), 11: (1, {'@': 1462}), 55: (1, {'@': 1462}), 17: (1, {'@': 1462}), 58: (1, {'@': 1462}), 59: (1, {'@': 1462}), 22: (1, {'@': 1462}), 62: (1, {'@': 1462}), 23: (1, {'@': 1462}), 25: (1, {'@': 1462}), 63: (1, {'@': 1462}), 31: (1, {'@': 1462}), 66: (1, {'@': 1462}), 36: (1, {'@': 1462}), 68: (1, {'@': 1462}), 70: (1, {'@': 1462}), 71: (1, {'@': 1462}), 72: (1, {'@': 1462}), 73: (1, {'@': 1462})}, 457: {126: (0, 2100)}, 458: {230: (1, {'@': 727}), 60: (1, {'@': 727}), 235: (1, {'@': 727}), 240: (1, {'@': 727}), 126: (1, {'@': 727}), 231: (1, {'@': 727}), 234: (1, {'@': 727}), 57: (1, {'@': 727}), 241: (1, {'@': 727}), 243: (1, {'@': 727})}, 459: {60: (1, {'@': 1690}), 147: (1, {'@': 1690}), 154: (1, {'@': 1690}), 148: (1, {'@': 1690}), 126: (1, {'@': 1690}), 149: (1, {'@': 1690}), 155: (1, {'@': 1690}), 151: (1, {'@': 1690}), 152: (1, {'@': 1690}), 150: (1, {'@': 1690}), 156: (1, {'@': 1690}), 157: (1, {'@': 1690}), 158: (1, {'@': 1690}), 159: (1, {'@': 1690}), 153: (1, {'@': 1690}), 57: (1, {'@': 1690}), 160: (1, {'@': 1690})}, 460: {126: (0, 1370)}, 461: {230: (1, {'@': 724}), 60: (1, {'@': 724}), 235: (1, {'@': 724}), 240: (1, {'@': 724}), 126: (1, {'@': 724}), 231: (1, {'@': 724}), 234: (1, {'@': 724}), 57: (1, {'@': 724}), 241: (1, {'@': 724}), 243: (1, {'@': 724})}, 462: {146: (0, 2061)}, 463: {126: (0, 1446)}, 464: {230: (1, {'@': 716}), 60: (1, {'@': 716}), 235: (1, {'@': 716}), 240: (1, {'@': 716}), 126: (1, {'@': 716}), 231: (1, {'@': 716}), 234: (1, {'@': 716}), 57: (1, {'@': 716}), 241: (1, {'@': 716}), 243: (1, {'@': 716})}, 465: {60: (0, 2071)}, 466: {60: (0, 441)}, 467: {126: (1, {'@': 1658}), 60: (1, {'@': 1658})}, 468: {146: (0, 2048)}, 469: {126: (0, 415)}, 470: {230: (1, {'@': 733}), 60: (1, {'@': 733}), 235: (1, {'@': 733}), 240: (1, {'@': 733}), 126: (1, {'@': 733}), 231: (1, {'@': 733}), 234: (1, {'@': 733}), 57: (1, {'@': 733}), 241: (1, {'@': 733}), 243: (1, {'@': 733})}, 471: {146: (0, 2031)}, 472: {126: (0, 419)}, 473: {230: (1, {'@': 730}), 60: (1, {'@': 730}), 235: (1, {'@': 730}), 240: (1, {'@': 730}), 126: (1, {'@': 730}), 231: (1, {'@': 730}), 234: (1, {'@': 730}), 57: (1, {'@': 730}), 241: (1, {'@': 730}), 243: (1, {'@': 730})}, 474: {60: (0, 2054)}, 475: {60: (0, 437)}, 476: {230: (1, {'@': 720}), 60: (1, {'@': 720}), 235: (1, {'@': 720}), 240: (1, {'@': 720}), 126: (1, {'@': 720}), 231: (1, {'@': 720}), 234: (1, {'@': 720}), 57: (1, {'@': 720}), 241: (1, {'@': 720}), 243: (1, {'@': 720})}, 477: {60: (1, {'@': 1296})}, 478: {126: (0, 443), 60: (1, {'@': 624})}, 479: {60: (0, 423)}, 480: {230: (1, {'@': 722}), 60: (1, {'@': 722}), 235: (1, {'@': 722}), 240: (1, {'@': 722}), 126: (1, {'@': 722}), 231: (1, {'@': 722}), 234: (1, {'@': 722}), 57: (1, {'@': 722}), 241: (1, {'@': 722}), 243: (1, {'@': 722})}, 481: {60: (1, {'@': 1082}), 125: (1, {'@': 1082}), 41: (1, {'@': 1082}), 127: (1, {'@': 1082}), 126: (1, {'@': 1082}), 53: (1, {'@': 1082}), 57: (1, {'@': 1082})}, 482: {80: (0, 2434), 107: (0, 2409), 112: (0, 2376), 81: (0, 2295), 399: (0, 2045), 97: (0, 2370), 89: (0, 2384), 497: (0, 2011)}, 483: {60: (0, 439)}, 484: {60: (1, {'@': 1080}), 125: (1, {'@': 1080}), 41: (1, {'@': 1080}), 127: (1, {'@': 1080}), 126: (1, {'@': 1080}), 53: (1, {'@': 1080}), 57: (1, {'@': 1080})}, 485: {60: (0, 2078)}, 486: {60: (1, {'@': 1217}), 7: (1, {'@': 1217}), 22: (1, {'@': 1217}), 126: (1, {'@': 1217}), 174: (1, {'@': 1217}), 175: (1, {'@': 1217}), 49: (1, {'@': 1217}), 57: (1, {'@': 1217}), 176: (1, {'@': 1217})}, 487: {146: (0, 2037)}, 488: {60: (1, {'@': 625})}, 489: {60: (1, {'@': 1229}), 7: (1, {'@': 1229}), 22: (1, {'@': 1229}), 126: (1, {'@': 1229}), 174: (1, {'@': 1229}), 175: (1, {'@': 1229}), 49: (1, {'@': 1229}), 57: (1, {'@': 1229}), 176: (1, {'@': 1229})}, 490: {80: (0, 2434), 107: (0, 2409), 112: (0, 2376), 81: (0, 2295), 399: (0, 2045), 497: (0, 2005), 97: (0, 2370), 89: (0, 2384)}, 491: {126: (1, {'@': 626}), 60: (1, {'@': 626})}, 492: {60: (1, {'@': 1359}), 57: (1, {'@': 1359})}, 493: {146: (1, {'@': 662})}, 494: {126: (0, 1644), 498: (0, 1659), 441: (0, 1661)}, 495: {60: (0, 428)}, 496: {146: (1, {'@': 663})}, 497: {60: (1, {'@': 990}), 57: (1, {'@': 990})}, 498: {60: (0, 448)}, 499: {126: (0, 1644), 498: (0, 1642), 441: (0, 1637)}, 500: {6: (1, {'@': 1667}), 60: (1, {'@': 1667}), 7: (1, {'@': 1667}), 61: (1, {'@': 1667}), 126: (1, {'@': 1667}), 37: (1, {'@': 1667}), 27: (1, {'@': 1667}), 28: (1, {'@': 1667}), 57: (1, {'@': 1667})}, 501: {126: (0, 191), 499: (0, 189), 60: (1, {'@': 719})}, 502: {60: (0, 450)}, 503: {112: (0, 1329)}, 504: {7: (0, 45), 27: (0, 408), 180: (0, 1621), 28: (0, 33), 169: (0, 1623), 426: (0, 2028), 61: (0, 25), 165: (0, 1626), 37: (0, 1828), 6: (0, 20), 185: (0, 1636), 183: (0, 1638), 164: (0, 1643)}, 505: {112: (0, 2199)}, 506: {60: (0, 455)}, 507: {60: (0, 1668), 126: (0, 1674)}, 508: {144: (0, 2316), 145: (0, 730)}, 509: {126: (1, {'@': 1602}), 146: (1, {'@': 1602})}, 510: {6: (1, {'@': 1670}), 60: (1, {'@': 1670}), 7: (1, {'@': 1670}), 61: (1, {'@': 1670}), 126: (1, {'@': 1670}), 37: (1, {'@': 1670}), 27: (1, {'@': 1670}), 28: (1, {'@': 1670}), 57: (1, {'@': 1670})}, 511: {60: (0, 453)}, 512: {126: (1, {'@': 1578}), 146: (1, {'@': 1578})}, 513: {60: (1, {'@': 1002})}, 514: {60: (1, {'@': 1113}), 57: (1, {'@': 1113})}, 515: {126: (1, {'@': 1581}), 146: (1, {'@': 1581})}, 516: {60: (1, {'@': 1001})}, 517: {126: (1, {'@': 1686}), 146: (1, {'@': 1686})}, 518: {500: (1, {'@': 544}), 60: (1, {'@': 544}), 501: (1, {'@': 544}), 126: (1, {'@': 544}), 57: (1, {'@': 544})}, 519: {60: (0, 458)}, 520: {80: (0, 2434), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 399: (0, 2050), 144: (0, 2006)}, 521: {60: (0, 461)}, 522: {126: (1, {'@': 1579}), 146: (1, {'@': 1579})}, 523: {57: (1, {'@': 1423}), 60: (1, {'@': 1423}), 6: (1, {'@': 1423}), 7: (1, {'@': 1423}), 61: (1, {'@': 1423}), 126: (1, {'@': 1423}), 28: (1, {'@': 1423}), 17: (1, {'@': 1423}), 59: (1, {'@': 1423}), 21: (1, {'@': 1423}), 22: (1, {'@': 1423}), 44: (1, {'@': 1423}), 62: (1, {'@': 1423}), 23: (1, {'@': 1423}), 25: (1, {'@': 1423}), 49: (1, {'@': 1423}), 33: (1, {'@': 1423}), 53: (1, {'@': 1423}), 69: (1, {'@': 1423}), 40: (1, {'@': 1423}), 41: (1, {'@': 1423}), 75: (1, {'@': 1423}), 73: (1, {'@': 1423}), 45: (1, {'@': 1423}), 37: (1, {'@': 1423}), 38: (1, {'@': 1423}), 47: (1, {'@': 1423}), 26: (1, {'@': 1423}), 27: (1, {'@': 1423}), 4: (1, {'@': 1423}), 50: (1, {'@': 1423}), 67: (1, {'@': 1423}), 29: (1, {'@': 1423}), 30: (1, {'@': 1423}), 15: (1, {'@': 1423}), 43: (1, {'@': 1423}), 64: (1, {'@': 1423}), 34: (1, {'@': 1423}), 54: (1, {'@': 1423}), 74: (1, {'@': 1423}), 18: (1, {'@': 1423}), 1: (1, {'@': 1423}), 2: (1, {'@': 1423}), 63: (1, {'@': 1423}), 52: (1, {'@': 1423}), 8: (1, {'@': 1423}), 71: (1, {'@': 1423}), 55: (1, {'@': 1423}), 48: (1, {'@': 1423}), 51: (1, {'@': 1423}), 9: (1, {'@': 1423}), 11: (1, {'@': 1423}), 58: (1, {'@': 1423}), 31: (1, {'@': 1423}), 66: (1, {'@': 1423}), 36: (1, {'@': 1423}), 68: (1, {'@': 1423}), 70: (1, {'@': 1423}), 72: (1, {'@': 1423})}, 524: {126: (1, {'@': 1582}), 146: (1, {'@': 1582})}, 525: {60: (0, 464)}, 526: {60: (0, 2000)}, 527: {126: (1, {'@': 1580}), 146: (1, {'@': 1580})}, 528: {126: (1, {'@': 1204}), 146: (1, {'@': 1204})}, 529: {146: (0, 2090)}, 530: {126: (1, {'@': 806}), 193: (1, {'@': 806}), 57: (1, {'@': 806}), 60: (1, {'@': 806})}, 531: {60: (0, 476)}, 532: {60: (0, 579)}, 533: {126: (1, {'@': 809}), 193: (1, {'@': 809}), 57: (1, {'@': 809}), 60: (1, {'@': 809})}, 534: {502: (0, 2066), 126: (0, 2055), 146: (1, {'@': 1197})}, 535: {60: (0, 470)}, 536: {268: (1, {'@': 646}), 60: (1, {'@': 646}), 126: (1, {'@': 646}), 67: (1, {'@': 646}), 270: (1, {'@': 646}), 4: (1, {'@': 646}), 266: (1, {'@': 646}), 30: (1, {'@': 646}), 57: (1, {'@': 646})}, 537: {126: (0, 2186), 146: (1, {'@': 1176})}, 538: {60: (0, 473)}, 539: {112: (1, {'@': 1725}), 441: (1, {'@': 1725}), 89: (1, {'@': 1725}), 442: (1, {'@': 1725}), 107: (1, {'@': 1725}), 443: (1, {'@': 1725}), 60: (1, {'@': 1725})}, 540: {126: (1, {'@': 1198}), 146: (1, {'@': 1198})}, 541: {60: (0, 489)}, 542: {112: (1, {'@': 1727}), 441: (1, {'@': 1727}), 89: (1, {'@': 1727}), 442: (1, {'@': 1727}), 107: (1, {'@': 1727}), 443: (1, {'@': 1727}), 60: (1, {'@': 1727})}, 543: {126: (1, {'@': 1206}), 146: (1, {'@': 1206})}, 544: {60: (0, 486)}, 545: {60: (0, 480)}, 546: {112: (1, {'@': 1723}), 441: (1, {'@': 1723}), 89: (1, {'@': 1723}), 442: (1, {'@': 1723}), 107: (1, {'@': 1723}), 443: (1, {'@': 1723}), 60: (1, {'@': 1723})}, 547: {126: (1, {'@': 1203}), 146: (1, {'@': 1203})}, 548: {60: (0, 481)}, 549: {268: (1, {'@': 641}), 60: (1, {'@': 641}), 126: (1, {'@': 641}), 67: (1, {'@': 641}), 270: (1, {'@': 641}), 4: (1, {'@': 641}), 266: (1, {'@': 641}), 30: (1, {'@': 641}), 57: (1, {'@': 641})}, 550: {126: (1, {'@': 1205}), 146: (1, {'@': 1205})}, 551: {60: (0, 484)}, 552: {268: (1, {'@': 643}), 60: (1, {'@': 643}), 126: (1, {'@': 643}), 67: (1, {'@': 643}), 270: (1, {'@': 643}), 4: (1, {'@': 643}), 266: (1, {'@': 643}), 30: (1, {'@': 643}), 57: (1, {'@': 643})}, 553: {126: (0, 2055), 502: (0, 2057), 146: (1, {'@': 1202})}, 554: {60: (0, 515)}, 555: {57: (1, {'@': 523}), 60: (1, {'@': 523})}, 556: {126: (1, {'@': 1685}), 146: (1, {'@': 1685})}, 557: {57: (1, {'@': 525}), 60: (1, {'@': 525})}, 558: {503: (0, 494), 504: (0, 499), 505: (0, 503), 506: (0, 505)}, 559: {146: (0, 2023)}, 560: {57: (1, {'@': 521}), 60: (1, {'@': 521})}, 561: {59: (1, {'@': 1497}), 60: (1, {'@': 1497}), 21: (1, {'@': 1497}), 22: (1, {'@': 1497}), 44: (1, {'@': 1497}), 126: (1, {'@': 1497}), 62: (1, {'@': 1497}), 61: (1, {'@': 1497}), 23: (1, {'@': 1497}), 25: (1, {'@': 1497}), 28: (1, {'@': 1497}), 49: (1, {'@': 1497}), 6: (1, {'@': 1497}), 33: (1, {'@': 1497}), 7: (1, {'@': 1497}), 53: (1, {'@': 1497}), 69: (1, {'@': 1497}), 40: (1, {'@': 1497}), 41: (1, {'@': 1497}), 75: (1, {'@': 1497}), 73: (1, {'@': 1497}), 57: (1, {'@': 1497}), 43: (1, {'@': 1497}), 45: (1, {'@': 1497}), 27: (1, {'@': 1497}), 64: (1, {'@': 1497}), 34: (1, {'@': 1497}), 37: (1, {'@': 1497}), 54: (1, {'@': 1497}), 38: (1, {'@': 1497}), 74: (1, {'@': 1497}), 18: (1, {'@': 1497}), 1: (1, {'@': 1497}), 2: (1, {'@': 1497}), 47: (1, {'@': 1497}), 48: (1, {'@': 1497}), 4: (1, {'@': 1497}), 50: (1, {'@': 1497}), 51: (1, {'@': 1497}), 52: (1, {'@': 1497}), 8: (1, {'@': 1497}), 9: (1, {'@': 1497}), 11: (1, {'@': 1497}), 55: (1, {'@': 1497}), 15: (1, {'@': 1497}), 17: (1, {'@': 1497}), 58: (1, {'@': 1497}), 26: (1, {'@': 1497}), 63: (1, {'@': 1497}), 29: (1, {'@': 1497}), 30: (1, {'@': 1497}), 31: (1, {'@': 1497}), 66: (1, {'@': 1497}), 67: (1, {'@': 1497}), 36: (1, {'@': 1497}), 68: (1, {'@': 1497}), 70: (1, {'@': 1497}), 71: (1, {'@': 1497}), 72: (1, {'@': 1497})}, 562: {115: (0, 44), 77: (0, 17), 507: (0, 2193), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 508: (0, 2194), 116: (0, 780), 509: (0, 1069), 46: (0, 781), 510: (0, 2198), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 86: (0, 2195), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 511: (0, 2187), 124: (0, 864)}, 563: {43: (1, {'@': 1503}), 60: (1, {'@': 1503}), 21: (1, {'@': 1503}), 44: (1, {'@': 1503}), 126: (1, {'@': 1503}), 61: (1, {'@': 1503}), 45: (1, {'@': 1503}), 27: (1, {'@': 1503}), 28: (1, {'@': 1503}), 6: (1, {'@': 1503}), 33: (1, {'@': 1503}), 64: (1, {'@': 1503}), 34: (1, {'@': 1503}), 53: (1, {'@': 1503}), 37: (1, {'@': 1503}), 54: (1, {'@': 1503}), 38: (1, {'@': 1503}), 69: (1, {'@': 1503}), 40: (1, {'@': 1503}), 74: (1, {'@': 1503}), 41: (1, {'@': 1503}), 75: (1, {'@': 1503}), 57: (1, {'@': 1503}), 18: (1, {'@': 1503}), 22: (1, {'@': 1503}), 62: (1, {'@': 1503}), 73: (1, {'@': 1503}), 1: (1, {'@': 1503}), 2: (1, {'@': 1503}), 47: (1, {'@': 1503}), 48: (1, {'@': 1503}), 4: (1, {'@': 1503}), 49: (1, {'@': 1503}), 50: (1, {'@': 1503}), 51: (1, {'@': 1503}), 52: (1, {'@': 1503}), 8: (1, {'@': 1503}), 7: (1, {'@': 1503}), 9: (1, {'@': 1503}), 11: (1, {'@': 1503}), 55: (1, {'@': 1503}), 15: (1, {'@': 1503}), 17: (1, {'@': 1503}), 58: (1, {'@': 1503}), 59: (1, {'@': 1503}), 23: (1, {'@': 1503}), 25: (1, {'@': 1503}), 26: (1, {'@': 1503}), 63: (1, {'@': 1503}), 29: (1, {'@': 1503}), 30: (1, {'@': 1503}), 31: (1, {'@': 1503}), 66: (1, {'@': 1503}), 67: (1, {'@': 1503}), 36: (1, {'@': 1503}), 68: (1, {'@': 1503}), 70: (1, {'@': 1503}), 71: (1, {'@': 1503}), 72: (1, {'@': 1503})}, 564: {512: (0, 2012), 513: (0, 1992), 514: (0, 1981), 515: (0, 1993), 516: (0, 1999), 517: (0, 2030), 518: (0, 2019), 519: (0, 2021)}, 565: {43: (1, {'@': 1057}), 60: (1, {'@': 1057}), 21: (1, {'@': 1057}), 44: (1, {'@': 1057}), 126: (1, {'@': 1057}), 61: (1, {'@': 1057}), 45: (1, {'@': 1057}), 27: (1, {'@': 1057}), 28: (1, {'@': 1057}), 6: (1, {'@': 1057}), 33: (1, {'@': 1057}), 64: (1, {'@': 1057}), 34: (1, {'@': 1057}), 53: (1, {'@': 1057}), 37: (1, {'@': 1057}), 54: (1, {'@': 1057}), 38: (1, {'@': 1057}), 69: (1, {'@': 1057}), 40: (1, {'@': 1057}), 74: (1, {'@': 1057}), 41: (1, {'@': 1057}), 75: (1, {'@': 1057}), 57: (1, {'@': 1057}), 18: (1, {'@': 1057}), 1: (1, {'@': 1057}), 2: (1, {'@': 1057}), 47: (1, {'@': 1057}), 48: (1, {'@': 1057}), 4: (1, {'@': 1057}), 49: (1, {'@': 1057}), 50: (1, {'@': 1057}), 51: (1, {'@': 1057}), 52: (1, {'@': 1057}), 8: (1, {'@': 1057}), 7: (1, {'@': 1057}), 9: (1, {'@': 1057}), 11: (1, {'@': 1057}), 55: (1, {'@': 1057}), 15: (1, {'@': 1057}), 17: (1, {'@': 1057}), 58: (1, {'@': 1057}), 59: (1, {'@': 1057}), 22: (1, {'@': 1057}), 62: (1, {'@': 1057}), 23: (1, {'@': 1057}), 25: (1, {'@': 1057}), 26: (1, {'@': 1057}), 63: (1, {'@': 1057}), 29: (1, {'@': 1057}), 30: (1, {'@': 1057}), 31: (1, {'@': 1057}), 66: (1, {'@': 1057}), 67: (1, {'@': 1057}), 36: (1, {'@': 1057}), 68: (1, {'@': 1057}), 70: (1, {'@': 1057}), 71: (1, {'@': 1057}), 72: (1, {'@': 1057}), 73: (1, {'@': 1057})}, 566: {57: (1, {'@': 1174}), 60: (1, {'@': 1174}), 43: (1, {'@': 1174}), 1: (1, {'@': 1174}), 2: (1, {'@': 1174}), 44: (1, {'@': 1174}), 45: (1, {'@': 1174}), 47: (1, {'@': 1174}), 48: (1, {'@': 1174}), 4: (1, {'@': 1174}), 49: (1, {'@': 1174}), 50: (1, {'@': 1174}), 51: (1, {'@': 1174}), 6: (1, {'@': 1174}), 52: (1, {'@': 1174}), 8: (1, {'@': 1174}), 7: (1, {'@': 1174}), 9: (1, {'@': 1174}), 53: (1, {'@': 1174}), 11: (1, {'@': 1174}), 54: (1, {'@': 1174}), 55: (1, {'@': 1174}), 15: (1, {'@': 1174}), 17: (1, {'@': 1174}), 18: (1, {'@': 1174}), 58: (1, {'@': 1174}), 59: (1, {'@': 1174}), 21: (1, {'@': 1174}), 22: (1, {'@': 1174}), 61: (1, {'@': 1174}), 126: (1, {'@': 1174}), 62: (1, {'@': 1174}), 23: (1, {'@': 1174}), 25: (1, {'@': 1174}), 26: (1, {'@': 1174}), 63: (1, {'@': 1174}), 27: (1, {'@': 1174}), 28: (1, {'@': 1174}), 29: (1, {'@': 1174}), 30: (1, {'@': 1174}), 31: (1, {'@': 1174}), 33: (1, {'@': 1174}), 64: (1, {'@': 1174}), 66: (1, {'@': 1174}), 67: (1, {'@': 1174}), 34: (1, {'@': 1174}), 36: (1, {'@': 1174}), 37: (1, {'@': 1174}), 68: (1, {'@': 1174}), 38: (1, {'@': 1174}), 69: (1, {'@': 1174}), 70: (1, {'@': 1174}), 71: (1, {'@': 1174}), 40: (1, {'@': 1174}), 72: (1, {'@': 1174}), 41: (1, {'@': 1174}), 73: (1, {'@': 1174}), 74: (1, {'@': 1174}), 75: (1, {'@': 1174})}, 567: {57: (1, {'@': 1183}), 60: (1, {'@': 1183})}, 568: {43: (1, {'@': 1485}), 60: (1, {'@': 1485}), 21: (1, {'@': 1485}), 44: (1, {'@': 1485}), 126: (1, {'@': 1485}), 61: (1, {'@': 1485}), 45: (1, {'@': 1485}), 27: (1, {'@': 1485}), 28: (1, {'@': 1485}), 6: (1, {'@': 1485}), 33: (1, {'@': 1485}), 64: (1, {'@': 1485}), 34: (1, {'@': 1485}), 53: (1, {'@': 1485}), 37: (1, {'@': 1485}), 54: (1, {'@': 1485}), 38: (1, {'@': 1485}), 69: (1, {'@': 1485}), 40: (1, {'@': 1485}), 74: (1, {'@': 1485}), 41: (1, {'@': 1485}), 75: (1, {'@': 1485}), 57: (1, {'@': 1485}), 18: (1, {'@': 1485}), 22: (1, {'@': 1485}), 62: (1, {'@': 1485}), 73: (1, {'@': 1485}), 1: (1, {'@': 1485}), 2: (1, {'@': 1485}), 47: (1, {'@': 1485}), 48: (1, {'@': 1485}), 4: (1, {'@': 1485}), 49: (1, {'@': 1485}), 50: (1, {'@': 1485}), 51: (1, {'@': 1485}), 52: (1, {'@': 1485}), 8: (1, {'@': 1485}), 7: (1, {'@': 1485}), 9: (1, {'@': 1485}), 11: (1, {'@': 1485}), 55: (1, {'@': 1485}), 15: (1, {'@': 1485}), 17: (1, {'@': 1485}), 58: (1, {'@': 1485}), 59: (1, {'@': 1485}), 23: (1, {'@': 1485}), 25: (1, {'@': 1485}), 26: (1, {'@': 1485}), 63: (1, {'@': 1485}), 29: (1, {'@': 1485}), 30: (1, {'@': 1485}), 31: (1, {'@': 1485}), 66: (1, {'@': 1485}), 67: (1, {'@': 1485}), 36: (1, {'@': 1485}), 68: (1, {'@': 1485}), 70: (1, {'@': 1485}), 71: (1, {'@': 1485}), 72: (1, {'@': 1485})}, 569: {112: (1, {'@': 1713}), 89: (1, {'@': 1713}), 97: (1, {'@': 1713}), 107: (1, {'@': 1713}), 126: (1, {'@': 1713}), 146: (1, {'@': 1713}), 60: (1, {'@': 1713})}, 570: {43: (1, {'@': 1500}), 60: (1, {'@': 1500}), 21: (1, {'@': 1500}), 44: (1, {'@': 1500}), 126: (1, {'@': 1500}), 61: (1, {'@': 1500}), 45: (1, {'@': 1500}), 27: (1, {'@': 1500}), 28: (1, {'@': 1500}), 6: (1, {'@': 1500}), 33: (1, {'@': 1500}), 64: (1, {'@': 1500}), 34: (1, {'@': 1500}), 53: (1, {'@': 1500}), 37: (1, {'@': 1500}), 54: (1, {'@': 1500}), 38: (1, {'@': 1500}), 69: (1, {'@': 1500}), 40: (1, {'@': 1500}), 74: (1, {'@': 1500}), 41: (1, {'@': 1500}), 75: (1, {'@': 1500}), 57: (1, {'@': 1500}), 18: (1, {'@': 1500}), 22: (1, {'@': 1500}), 62: (1, {'@': 1500}), 73: (1, {'@': 1500}), 1: (1, {'@': 1500}), 2: (1, {'@': 1500}), 47: (1, {'@': 1500}), 48: (1, {'@': 1500}), 4: (1, {'@': 1500}), 49: (1, {'@': 1500}), 50: (1, {'@': 1500}), 51: (1, {'@': 1500}), 52: (1, {'@': 1500}), 8: (1, {'@': 1500}), 7: (1, {'@': 1500}), 9: (1, {'@': 1500}), 11: (1, {'@': 1500}), 55: (1, {'@': 1500}), 15: (1, {'@': 1500}), 17: (1, {'@': 1500}), 58: (1, {'@': 1500}), 59: (1, {'@': 1500}), 23: (1, {'@': 1500}), 25: (1, {'@': 1500}), 26: (1, {'@': 1500}), 63: (1, {'@': 1500}), 29: (1, {'@': 1500}), 30: (1, {'@': 1500}), 31: (1, {'@': 1500}), 66: (1, {'@': 1500}), 67: (1, {'@': 1500}), 36: (1, {'@': 1500}), 68: (1, {'@': 1500}), 70: (1, {'@': 1500}), 71: (1, {'@': 1500}), 72: (1, {'@': 1500})}, 571: {175: (0, 940), 157: (0, 2016), 254: (0, 2022), 253: (0, 2087), 520: (0, 2009), 174: (0, 953)}, 572: {146: (0, 2039)}, 573: {43: (1, {'@': 1480}), 60: (1, {'@': 1480}), 21: (1, {'@': 1480}), 44: (1, {'@': 1480}), 126: (1, {'@': 1480}), 61: (1, {'@': 1480}), 45: (1, {'@': 1480}), 27: (1, {'@': 1480}), 28: (1, {'@': 1480}), 6: (1, {'@': 1480}), 33: (1, {'@': 1480}), 64: (1, {'@': 1480}), 34: (1, {'@': 1480}), 53: (1, {'@': 1480}), 37: (1, {'@': 1480}), 54: (1, {'@': 1480}), 38: (1, {'@': 1480}), 69: (1, {'@': 1480}), 40: (1, {'@': 1480}), 74: (1, {'@': 1480}), 41: (1, {'@': 1480}), 75: (1, {'@': 1480}), 57: (1, {'@': 1480}), 18: (1, {'@': 1480}), 22: (1, {'@': 1480}), 62: (1, {'@': 1480}), 73: (1, {'@': 1480}), 1: (1, {'@': 1480}), 2: (1, {'@': 1480}), 47: (1, {'@': 1480}), 48: (1, {'@': 1480}), 4: (1, {'@': 1480}), 49: (1, {'@': 1480}), 50: (1, {'@': 1480}), 51: (1, {'@': 1480}), 52: (1, {'@': 1480}), 8: (1, {'@': 1480}), 7: (1, {'@': 1480}), 9: (1, {'@': 1480}), 11: (1, {'@': 1480}), 55: (1, {'@': 1480}), 15: (1, {'@': 1480}), 17: (1, {'@': 1480}), 58: (1, {'@': 1480}), 59: (1, {'@': 1480}), 23: (1, {'@': 1480}), 25: (1, {'@': 1480}), 26: (1, {'@': 1480}), 63: (1, {'@': 1480}), 29: (1, {'@': 1480}), 30: (1, {'@': 1480}), 31: (1, {'@': 1480}), 66: (1, {'@': 1480}), 67: (1, {'@': 1480}), 36: (1, {'@': 1480}), 68: (1, {'@': 1480}), 70: (1, {'@': 1480}), 71: (1, {'@': 1480}), 72: (1, {'@': 1480})}, 574: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 86: (0, 1948), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 194: (0, 1952), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 575: {126: (0, 2014)}, 576: {126: (0, 431), 521: (0, 507), 60: (0, 509)}, 577: {43: (1, {'@': 1051}), 60: (1, {'@': 1051}), 21: (1, {'@': 1051}), 44: (1, {'@': 1051}), 126: (1, {'@': 1051}), 61: (1, {'@': 1051}), 45: (1, {'@': 1051}), 27: (1, {'@': 1051}), 28: (1, {'@': 1051}), 6: (1, {'@': 1051}), 33: (1, {'@': 1051}), 64: (1, {'@': 1051}), 34: (1, {'@': 1051}), 53: (1, {'@': 1051}), 37: (1, {'@': 1051}), 54: (1, {'@': 1051}), 38: (1, {'@': 1051}), 69: (1, {'@': 1051}), 40: (1, {'@': 1051}), 74: (1, {'@': 1051}), 41: (1, {'@': 1051}), 75: (1, {'@': 1051}), 57: (1, {'@': 1051}), 18: (1, {'@': 1051}), 1: (1, {'@': 1051}), 2: (1, {'@': 1051}), 47: (1, {'@': 1051}), 48: (1, {'@': 1051}), 4: (1, {'@': 1051}), 49: (1, {'@': 1051}), 50: (1, {'@': 1051}), 51: (1, {'@': 1051}), 52: (1, {'@': 1051}), 8: (1, {'@': 1051}), 7: (1, {'@': 1051}), 9: (1, {'@': 1051}), 11: (1, {'@': 1051}), 55: (1, {'@': 1051}), 15: (1, {'@': 1051}), 17: (1, {'@': 1051}), 58: (1, {'@': 1051}), 59: (1, {'@': 1051}), 22: (1, {'@': 1051}), 62: (1, {'@': 1051}), 23: (1, {'@': 1051}), 25: (1, {'@': 1051}), 26: (1, {'@': 1051}), 63: (1, {'@': 1051}), 29: (1, {'@': 1051}), 30: (1, {'@': 1051}), 31: (1, {'@': 1051}), 66: (1, {'@': 1051}), 67: (1, {'@': 1051}), 36: (1, {'@': 1051}), 68: (1, {'@': 1051}), 70: (1, {'@': 1051}), 71: (1, {'@': 1051}), 72: (1, {'@': 1051}), 73: (1, {'@': 1051})}, 578: {293: (1, {'@': 750}), 60: (1, {'@': 750}), 52: (1, {'@': 750}), 8: (1, {'@': 750}), 126: (1, {'@': 750}), 57: (1, {'@': 750}), 2: (1, {'@': 750}), 44: (1, {'@': 750}), 61: (1, {'@': 750}), 63: (1, {'@': 750}), 28: (1, {'@': 750}), 33: (1, {'@': 750}), 6: (1, {'@': 750}), 53: (1, {'@': 750}), 37: (1, {'@': 750}), 71: (1, {'@': 750}), 55: (1, {'@': 750}), 43: (1, {'@': 750}), 1: (1, {'@': 750}), 45: (1, {'@': 750}), 47: (1, {'@': 750}), 48: (1, {'@': 750}), 4: (1, {'@': 750}), 49: (1, {'@': 750}), 50: (1, {'@': 750}), 51: (1, {'@': 750}), 7: (1, {'@': 750}), 9: (1, {'@': 750}), 11: (1, {'@': 750}), 54: (1, {'@': 750}), 15: (1, {'@': 750}), 17: (1, {'@': 750}), 18: (1, {'@': 750}), 58: (1, {'@': 750}), 59: (1, {'@': 750}), 21: (1, {'@': 750}), 22: (1, {'@': 750}), 62: (1, {'@': 750}), 23: (1, {'@': 750}), 25: (1, {'@': 750}), 26: (1, {'@': 750}), 27: (1, {'@': 750}), 29: (1, {'@': 750}), 30: (1, {'@': 750}), 31: (1, {'@': 750}), 64: (1, {'@': 750}), 66: (1, {'@': 750}), 67: (1, {'@': 750}), 34: (1, {'@': 750}), 36: (1, {'@': 750}), 68: (1, {'@': 750}), 38: (1, {'@': 750}), 69: (1, {'@': 750}), 70: (1, {'@': 750}), 40: (1, {'@': 750}), 72: (1, {'@': 750}), 41: (1, {'@': 750}), 73: (1, {'@': 750}), 74: (1, {'@': 750}), 75: (1, {'@': 750})}, 579: {57: (1, {'@': 1195}), 60: (1, {'@': 1195}), 43: (1, {'@': 1195}), 1: (1, {'@': 1195}), 2: (1, {'@': 1195}), 44: (1, {'@': 1195}), 45: (1, {'@': 1195}), 47: (1, {'@': 1195}), 48: (1, {'@': 1195}), 4: (1, {'@': 1195}), 49: (1, {'@': 1195}), 50: (1, {'@': 1195}), 51: (1, {'@': 1195}), 6: (1, {'@': 1195}), 52: (1, {'@': 1195}), 8: (1, {'@': 1195}), 7: (1, {'@': 1195}), 9: (1, {'@': 1195}), 53: (1, {'@': 1195}), 11: (1, {'@': 1195}), 54: (1, {'@': 1195}), 55: (1, {'@': 1195}), 15: (1, {'@': 1195}), 17: (1, {'@': 1195}), 18: (1, {'@': 1195}), 58: (1, {'@': 1195}), 59: (1, {'@': 1195}), 21: (1, {'@': 1195}), 22: (1, {'@': 1195}), 61: (1, {'@': 1195}), 126: (1, {'@': 1195}), 62: (1, {'@': 1195}), 23: (1, {'@': 1195}), 25: (1, {'@': 1195}), 26: (1, {'@': 1195}), 63: (1, {'@': 1195}), 27: (1, {'@': 1195}), 28: (1, {'@': 1195}), 29: (1, {'@': 1195}), 30: (1, {'@': 1195}), 31: (1, {'@': 1195}), 33: (1, {'@': 1195}), 64: (1, {'@': 1195}), 66: (1, {'@': 1195}), 67: (1, {'@': 1195}), 34: (1, {'@': 1195}), 36: (1, {'@': 1195}), 37: (1, {'@': 1195}), 68: (1, {'@': 1195}), 38: (1, {'@': 1195}), 69: (1, {'@': 1195}), 70: (1, {'@': 1195}), 71: (1, {'@': 1195}), 40: (1, {'@': 1195}), 72: (1, {'@': 1195}), 41: (1, {'@': 1195}), 73: (1, {'@': 1195}), 74: (1, {'@': 1195}), 75: (1, {'@': 1195})}, 580: {126: (1, {'@': 1607}), 60: (1, {'@': 1607})}, 581: {293: (1, {'@': 752}), 60: (1, {'@': 752}), 52: (1, {'@': 752}), 8: (1, {'@': 752}), 126: (1, {'@': 752}), 57: (1, {'@': 752}), 2: (1, {'@': 752}), 44: (1, {'@': 752}), 61: (1, {'@': 752}), 63: (1, {'@': 752}), 28: (1, {'@': 752}), 33: (1, {'@': 752}), 6: (1, {'@': 752}), 53: (1, {'@': 752}), 37: (1, {'@': 752}), 71: (1, {'@': 752}), 55: (1, {'@': 752}), 43: (1, {'@': 752}), 1: (1, {'@': 752}), 45: (1, {'@': 752}), 47: (1, {'@': 752}), 48: (1, {'@': 752}), 4: (1, {'@': 752}), 49: (1, {'@': 752}), 50: (1, {'@': 752}), 51: (1, {'@': 752}), 7: (1, {'@': 752}), 9: (1, {'@': 752}), 11: (1, {'@': 752}), 54: (1, {'@': 752}), 15: (1, {'@': 752}), 17: (1, {'@': 752}), 18: (1, {'@': 752}), 58: (1, {'@': 752}), 59: (1, {'@': 752}), 21: (1, {'@': 752}), 22: (1, {'@': 752}), 62: (1, {'@': 752}), 23: (1, {'@': 752}), 25: (1, {'@': 752}), 26: (1, {'@': 752}), 27: (1, {'@': 752}), 29: (1, {'@': 752}), 30: (1, {'@': 752}), 31: (1, {'@': 752}), 64: (1, {'@': 752}), 66: (1, {'@': 752}), 67: (1, {'@': 752}), 34: (1, {'@': 752}), 36: (1, {'@': 752}), 68: (1, {'@': 752}), 38: (1, {'@': 752}), 69: (1, {'@': 752}), 70: (1, {'@': 752}), 40: (1, {'@': 752}), 72: (1, {'@': 752}), 41: (1, {'@': 752}), 73: (1, {'@': 752}), 74: (1, {'@': 752}), 75: (1, {'@': 752})}, 582: {60: (0, 522)}, 583: {112: (1, {'@': 1307}), 57: (1, {'@': 1307}), 60: (1, {'@': 1307}), 147: (1, {'@': 1307}), 126: (1, {'@': 1307}), 148: (1, {'@': 1307}), 149: (1, {'@': 1307}), 150: (1, {'@': 1307}), 151: (1, {'@': 1307}), 152: (1, {'@': 1307}), 153: (1, {'@': 1307}), 154: (1, {'@': 1307}), 155: (1, {'@': 1307}), 156: (1, {'@': 1307}), 157: (1, {'@': 1307}), 158: (1, {'@': 1307}), 159: (1, {'@': 1307}), 160: (1, {'@': 1307})}, 584: {60: (0, 524)}, 585: {293: (1, {'@': 746}), 60: (1, {'@': 746}), 52: (1, {'@': 746}), 8: (1, {'@': 746}), 126: (1, {'@': 746}), 57: (1, {'@': 746})}, 586: {60: (0, 527)}, 587: {60: (0, 595)}, 588: {33: (1, {'@': 865}), 58: (1, {'@': 865}), 6: (1, {'@': 865}), 60: (1, {'@': 865}), 44: (1, {'@': 865}), 66: (1, {'@': 865}), 53: (1, {'@': 865}), 126: (1, {'@': 865}), 37: (1, {'@': 865}), 28: (1, {'@': 865}), 57: (1, {'@': 865}), 43: (1, {'@': 865}), 1: (1, {'@': 865}), 2: (1, {'@': 865}), 45: (1, {'@': 865}), 47: (1, {'@': 865}), 48: (1, {'@': 865}), 4: (1, {'@': 865}), 49: (1, {'@': 865}), 50: (1, {'@': 865}), 51: (1, {'@': 865}), 52: (1, {'@': 865}), 8: (1, {'@': 865}), 7: (1, {'@': 865}), 9: (1, {'@': 865}), 11: (1, {'@': 865}), 54: (1, {'@': 865}), 55: (1, {'@': 865}), 15: (1, {'@': 865}), 17: (1, {'@': 865}), 18: (1, {'@': 865}), 59: (1, {'@': 865}), 21: (1, {'@': 865}), 22: (1, {'@': 865}), 61: (1, {'@': 865}), 62: (1, {'@': 865}), 23: (1, {'@': 865}), 25: (1, {'@': 865}), 26: (1, {'@': 865}), 63: (1, {'@': 865}), 27: (1, {'@': 865}), 29: (1, {'@': 865}), 30: (1, {'@': 865}), 31: (1, {'@': 865}), 64: (1, {'@': 865}), 67: (1, {'@': 865}), 34: (1, {'@': 865}), 36: (1, {'@': 865}), 68: (1, {'@': 865}), 38: (1, {'@': 865}), 69: (1, {'@': 865}), 70: (1, {'@': 865}), 71: (1, {'@': 865}), 40: (1, {'@': 865}), 72: (1, {'@': 865}), 41: (1, {'@': 865}), 73: (1, {'@': 865}), 74: (1, {'@': 865}), 75: (1, {'@': 865})}, 589: {60: (1, {'@': 772}), 57: (1, {'@': 772})}, 590: {60: (1, {'@': 774}), 57: (1, {'@': 774})}, 591: {33: (1, {'@': 859}), 58: (1, {'@': 859}), 6: (1, {'@': 859}), 60: (1, {'@': 859}), 44: (1, {'@': 859}), 66: (1, {'@': 859}), 53: (1, {'@': 859}), 126: (1, {'@': 859}), 37: (1, {'@': 859}), 28: (1, {'@': 859}), 57: (1, {'@': 859}), 43: (1, {'@': 859}), 1: (1, {'@': 859}), 2: (1, {'@': 859}), 45: (1, {'@': 859}), 47: (1, {'@': 859}), 48: (1, {'@': 859}), 4: (1, {'@': 859}), 49: (1, {'@': 859}), 50: (1, {'@': 859}), 51: (1, {'@': 859}), 52: (1, {'@': 859}), 8: (1, {'@': 859}), 7: (1, {'@': 859}), 9: (1, {'@': 859}), 11: (1, {'@': 859}), 54: (1, {'@': 859}), 55: (1, {'@': 859}), 15: (1, {'@': 859}), 17: (1, {'@': 859}), 18: (1, {'@': 859}), 59: (1, {'@': 859}), 21: (1, {'@': 859}), 22: (1, {'@': 859}), 61: (1, {'@': 859}), 62: (1, {'@': 859}), 23: (1, {'@': 859}), 25: (1, {'@': 859}), 26: (1, {'@': 859}), 63: (1, {'@': 859}), 27: (1, {'@': 859}), 29: (1, {'@': 859}), 30: (1, {'@': 859}), 31: (1, {'@': 859}), 64: (1, {'@': 859}), 67: (1, {'@': 859}), 34: (1, {'@': 859}), 36: (1, {'@': 859}), 68: (1, {'@': 859}), 38: (1, {'@': 859}), 69: (1, {'@': 859}), 70: (1, {'@': 859}), 71: (1, {'@': 859}), 40: (1, {'@': 859}), 72: (1, {'@': 859}), 41: (1, {'@': 859}), 73: (1, {'@': 859}), 74: (1, {'@': 859}), 75: (1, {'@': 859})}, 592: {146: (0, 1997)}, 593: {60: (0, 1995)}, 594: {60: (0, 578)}, 595: {126: (1, {'@': 768}), 193: (1, {'@': 768}), 57: (1, {'@': 768}), 60: (1, {'@': 768})}, 596: {57: (1, {'@': 1064}), 60: (1, {'@': 1064})}, 597: {60: (0, 577)}, 598: {60: (0, 1732)}, 599: {522: (0, 623), 523: (0, 1714), 126: (0, 1711)}, 600: {126: (0, 654), 60: (1, {'@': 1171})}, 601: {212: (0, 1759), 59: (0, 363), 60: (1, {'@': 529}), 57: (1, {'@': 529})}, 602: {146: (0, 1154)}, 603: {60: (1, {'@': 1297}), 147: (1, {'@': 1297}), 126: (1, {'@': 1297}), 148: (1, {'@': 1297}), 149: (1, {'@': 1297}), 150: (1, {'@': 1297}), 151: (1, {'@': 1297}), 152: (1, {'@': 1297}), 153: (1, {'@': 1297}), 154: (1, {'@': 1297}), 155: (1, {'@': 1297}), 156: (1, {'@': 1297}), 157: (1, {'@': 1297}), 158: (1, {'@': 1297}), 159: (1, {'@': 1297}), 57: (1, {'@': 1297}), 160: (1, {'@': 1297})}, 604: {146: (1, {'@': 864})}, 605: {60: (1, {'@': 1286}), 147: (1, {'@': 1286}), 126: (1, {'@': 1286}), 148: (1, {'@': 1286}), 149: (1, {'@': 1286}), 150: (1, {'@': 1286}), 151: (1, {'@': 1286}), 152: (1, {'@': 1286}), 153: (1, {'@': 1286}), 154: (1, {'@': 1286}), 155: (1, {'@': 1286}), 156: (1, {'@': 1286}), 157: (1, {'@': 1286}), 158: (1, {'@': 1286}), 159: (1, {'@': 1286}), 57: (1, {'@': 1286}), 160: (1, {'@': 1286})}, 606: {60: (0, 1150)}, 607: {60: (0, 565)}, 608: {60: (1, {'@': 1235}), 147: (1, {'@': 1235}), 126: (1, {'@': 1235}), 148: (1, {'@': 1235}), 149: (1, {'@': 1235}), 150: (1, {'@': 1235}), 151: (1, {'@': 1235}), 152: (1, {'@': 1235}), 153: (1, {'@': 1235}), 154: (1, {'@': 1235}), 155: (1, {'@': 1235}), 156: (1, {'@': 1235}), 157: (1, {'@': 1235}), 158: (1, {'@': 1235}), 159: (1, {'@': 1235}), 57: (1, {'@': 1235}), 160: (1, {'@': 1235})}, 609: {60: (0, 585)}, 610: {80: (0, 2434), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 399: (0, 1719), 112: (0, 2376), 97: (0, 2370)}, 611: {146: (0, 1188)}, 612: {60: (0, 591)}, 613: {524: (0, 737), 126: (0, 726), 525: (0, 1767)}, 614: {146: (0, 1145)}, 615: {60: (1, {'@': 508}), 57: (1, {'@': 508})}, 616: {146: (0, 1192)}, 617: {60: (1, {'@': 1292}), 147: (1, {'@': 1292}), 126: (1, {'@': 1292}), 148: (1, {'@': 1292}), 149: (1, {'@': 1292}), 150: (1, {'@': 1292}), 151: (1, {'@': 1292}), 152: (1, {'@': 1292}), 153: (1, {'@': 1292}), 154: (1, {'@': 1292}), 155: (1, {'@': 1292}), 156: (1, {'@': 1292}), 157: (1, {'@': 1292}), 158: (1, {'@': 1292}), 159: (1, {'@': 1292}), 57: (1, {'@': 1292}), 160: (1, {'@': 1292})}, 618: {60: (0, 570)}, 619: {526: (0, 1959), 59: (0, 363), 212: (0, 746)}, 620: {60: (0, 1191)}, 621: {60: (1, {'@': 1283}), 147: (1, {'@': 1283}), 126: (1, {'@': 1283}), 148: (1, {'@': 1283}), 149: (1, {'@': 1283}), 150: (1, {'@': 1283}), 151: (1, {'@': 1283}), 152: (1, {'@': 1283}), 153: (1, {'@': 1283}), 154: (1, {'@': 1283}), 155: (1, {'@': 1283}), 156: (1, {'@': 1283}), 157: (1, {'@': 1283}), 158: (1, {'@': 1283}), 159: (1, {'@': 1283}), 57: (1, {'@': 1283}), 160: (1, {'@': 1283})}, 622: {60: (1, {'@': 1343}), 57: (1, {'@': 1343})}, 623: {112: (0, 574)}, 624: {60: (0, 2018)}, 625: {60: (1, {'@': 1280}), 147: (1, {'@': 1280}), 126: (1, {'@': 1280}), 148: (1, {'@': 1280}), 149: (1, {'@': 1280}), 150: (1, {'@': 1280}), 151: (1, {'@': 1280}), 152: (1, {'@': 1280}), 153: (1, {'@': 1280}), 154: (1, {'@': 1280}), 155: (1, {'@': 1280}), 156: (1, {'@': 1280}), 157: (1, {'@': 1280}), 158: (1, {'@': 1280}), 159: (1, {'@': 1280}), 57: (1, {'@': 1280}), 160: (1, {'@': 1280})}, 626: {146: (1, {'@': 1352}), 126: (1, {'@': 1352})}, 627: {60: (0, 568)}, 628: {60: (0, 588)}, 629: {126: (1, {'@': 1733}), 60: (1, {'@': 1733}), 146: (1, {'@': 1733})}, 630: {57: (1, {'@': 561}), 60: (1, {'@': 561})}, 631: {60: (0, 557)}, 632: {60: (1, {'@': 1277}), 147: (1, {'@': 1277}), 126: (1, {'@': 1277}), 148: (1, {'@': 1277}), 149: (1, {'@': 1277}), 150: (1, {'@': 1277}), 151: (1, {'@': 1277}), 152: (1, {'@': 1277}), 153: (1, {'@': 1277}), 154: (1, {'@': 1277}), 155: (1, {'@': 1277}), 156: (1, {'@': 1277}), 157: (1, {'@': 1277}), 158: (1, {'@': 1277}), 159: (1, {'@': 1277}), 57: (1, {'@': 1277}), 160: (1, {'@': 1277})}, 633: {60: (1, {'@': 1677}), 21: (1, {'@': 1677}), 22: (1, {'@': 1677}), 44: (1, {'@': 1677}), 126: (1, {'@': 1677}), 62: (1, {'@': 1677}), 61: (1, {'@': 1677}), 28: (1, {'@': 1677}), 33: (1, {'@': 1677}), 6: (1, {'@': 1677}), 64: (1, {'@': 1677}), 34: (1, {'@': 1677}), 53: (1, {'@': 1677}), 54: (1, {'@': 1677}), 69: (1, {'@': 1677}), 40: (1, {'@': 1677}), 73: (1, {'@': 1677}), 75: (1, {'@': 1677}), 57: (1, {'@': 1677}), 18: (1, {'@': 1677})}, 634: {500: (1, {'@': 1619}), 60: (1, {'@': 1619}), 501: (1, {'@': 1619}), 126: (1, {'@': 1619}), 57: (1, {'@': 1619})}, 635: {22: (0, 389), 53: (0, 387), 18: (0, 1581), 172: (0, 1872), 33: (0, 383), 64: (0, 1537), 200: (0, 1876), 44: (0, 358), 183: (0, 1880), 62: (0, 367), 21: (0, 366), 164: (0, 1883), 287: (0, 1886), 204: (0, 1889), 75: (0, 341), 34: (0, 1589), 28: (0, 33), 61: (0, 25), 208: (0, 1904), 205: (0, 1907), 207: (0, 1912), 280: (0, 1916), 213: (0, 1919), 54: (0, 1598), 283: (0, 1922), 40: (0, 1756), 69: (0, 1760), 185: (0, 1932), 211: (0, 1936), 210: (0, 1941), 206: (0, 1946), 73: (0, 1763), 6: (0, 20), 476: (0, 1198), 286: (0, 1951)}, 636: {177: (1, {'@': 599}), 7: (1, {'@': 599}), 22: (1, {'@': 599}), 60: (1, {'@': 599}), 126: (1, {'@': 599}), 48: (1, {'@': 599}), 72: (1, {'@': 599}), 178: (1, {'@': 599}), 179: (1, {'@': 599}), 49: (1, {'@': 599}), 57: (1, {'@': 599})}, 637: {126: (1, {'@': 1577}), 146: (1, {'@': 1577})}, 638: {60: (0, 555)}, 639: {60: (1, {'@': 1680}), 21: (1, {'@': 1680}), 22: (1, {'@': 1680}), 44: (1, {'@': 1680}), 126: (1, {'@': 1680}), 62: (1, {'@': 1680}), 61: (1, {'@': 1680}), 28: (1, {'@': 1680}), 33: (1, {'@': 1680}), 6: (1, {'@': 1680}), 64: (1, {'@': 1680}), 34: (1, {'@': 1680}), 53: (1, {'@': 1680}), 54: (1, {'@': 1680}), 69: (1, {'@': 1680}), 40: (1, {'@': 1680}), 73: (1, {'@': 1680}), 75: (1, {'@': 1680}), 57: (1, {'@': 1680}), 18: (1, {'@': 1680})}, 640: {60: (0, 581)}, 641: {126: (1, {'@': 1682}), 146: (1, {'@': 1682})}, 642: {126: (0, 1056), 146: (1, {'@': 1348})}, 643: {146: (1, {'@': 558})}, 644: {146: (1, {'@': 1351}), 126: (1, {'@': 1351})}, 645: {126: (1, {'@': 1576}), 146: (1, {'@': 1576})}, 646: {146: (1, {'@': 1061})}, 647: {126: (0, 1187)}, 648: {60: (0, 549)}, 649: {60: (1, {'@': 1289}), 147: (1, {'@': 1289}), 126: (1, {'@': 1289}), 148: (1, {'@': 1289}), 149: (1, {'@': 1289}), 150: (1, {'@': 1289}), 151: (1, {'@': 1289}), 152: (1, {'@': 1289}), 153: (1, {'@': 1289}), 154: (1, {'@': 1289}), 155: (1, {'@': 1289}), 156: (1, {'@': 1289}), 157: (1, {'@': 1289}), 158: (1, {'@': 1289}), 159: (1, {'@': 1289}), 57: (1, {'@': 1289}), 160: (1, {'@': 1289})}, 650: {146: (0, 1213)}, 651: {146: (1, {'@': 1055})}, 652: {60: (0, 1195)}, 653: {60: (0, 546)}, 654: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 86: (0, 1697), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 655: {146: (0, 1097)}, 656: {60: (0, 563)}, 657: {60: (1, {'@': 759}), 57: (1, {'@': 759})}, 658: {146: (0, 1063)}, 659: {112: (1, {'@': 1724}), 441: (1, {'@': 1724}), 89: (1, {'@': 1724}), 442: (1, {'@': 1724}), 107: (1, {'@': 1724}), 443: (1, {'@': 1724}), 60: (1, {'@': 1724})}, 660: {60: (0, 1175)}, 661: {443: (0, 542)}, 662: {60: (0, 573)}, 663: {126: (0, 1204), 146: (1, {'@': 834})}, 664: {112: (1, {'@': 1728}), 441: (1, {'@': 1728}), 89: (1, {'@': 1728}), 442: (1, {'@': 1728}), 107: (1, {'@': 1728}), 443: (1, {'@': 1728}), 60: (1, {'@': 1728})}, 665: {126: (0, 1182), 146: (1, {'@': 833})}, 666: {501: (0, 1985), 500: (0, 2010), 527: (0, 2231), 528: (0, 2454), 529: (0, 1704)}, 667: {441: (0, 539)}, 668: {60: (0, 1201)}, 669: {81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 76: (0, 710), 80: (0, 2149)}, 670: {112: (0, 1717)}, 671: {60: (1, {'@': 840})}, 672: {112: (1, {'@': 1726}), 441: (1, {'@': 1726}), 89: (1, {'@': 1726}), 442: (1, {'@': 1726}), 107: (1, {'@': 1726}), 443: (1, {'@': 1726}), 60: (1, {'@': 1726})}, 673: {112: (1, {'@': 1720}), 441: (1, {'@': 1720}), 89: (1, {'@': 1720}), 442: (1, {'@': 1720}), 107: (1, {'@': 1720}), 443: (1, {'@': 1720}), 60: (1, {'@': 1720})}, 674: {530: (0, 1699), 531: (0, 1354), 532: (0, 1356), 533: (0, 1360), 534: (0, 1352), 535: (0, 1362)}, 675: {60: (1, {'@': 842})}, 676: {60: (0, 1639)}, 677: {146: (1, {'@': 1062})}, 678: {33: (1, {'@': 1659}), 2: (1, {'@': 1659}), 6: (1, {'@': 1659}), 52: (1, {'@': 1659}), 8: (1, {'@': 1659}), 44: (1, {'@': 1659}), 61: (1, {'@': 1659}), 53: (1, {'@': 1659}), 126: (1, {'@': 1659}), 60: (1, {'@': 1659}), 37: (1, {'@': 1659}), 71: (1, {'@': 1659}), 63: (1, {'@': 1659}), 55: (1, {'@': 1659}), 28: (1, {'@': 1659}), 57: (1, {'@': 1659})}, 679: {112: (1, {'@': 1718}), 441: (1, {'@': 1718}), 89: (1, {'@': 1718}), 442: (1, {'@': 1718}), 107: (1, {'@': 1718}), 443: (1, {'@': 1718}), 60: (1, {'@': 1718})}, 680: {146: (0, 1691)}, 681: {60: (0, 1211)}, 682: {60: (0, 552)}, 683: {146: (0, 1683)}, 684: {57: (1, {'@': 780}), 60: (1, {'@': 780})}, 685: {177: (1, {'@': 603}), 7: (1, {'@': 603}), 22: (1, {'@': 603}), 60: (1, {'@': 603}), 126: (1, {'@': 603}), 48: (1, {'@': 603}), 72: (1, {'@': 603}), 178: (1, {'@': 603}), 179: (1, {'@': 603}), 49: (1, {'@': 603}), 57: (1, {'@': 603}), 43: (1, {'@': 603}), 1: (1, {'@': 603}), 2: (1, {'@': 603}), 44: (1, {'@': 603}), 45: (1, {'@': 603}), 47: (1, {'@': 603}), 4: (1, {'@': 603}), 50: (1, {'@': 603}), 51: (1, {'@': 603}), 6: (1, {'@': 603}), 52: (1, {'@': 603}), 8: (1, {'@': 603}), 9: (1, {'@': 603}), 53: (1, {'@': 603}), 11: (1, {'@': 603}), 54: (1, {'@': 603}), 55: (1, {'@': 603}), 15: (1, {'@': 603}), 17: (1, {'@': 603}), 18: (1, {'@': 603}), 58: (1, {'@': 603}), 59: (1, {'@': 603}), 21: (1, {'@': 603}), 61: (1, {'@': 603}), 62: (1, {'@': 603}), 23: (1, {'@': 603}), 25: (1, {'@': 603}), 26: (1, {'@': 603}), 63: (1, {'@': 603}), 27: (1, {'@': 603}), 28: (1, {'@': 603}), 29: (1, {'@': 603}), 30: (1, {'@': 603}), 31: (1, {'@': 603}), 33: (1, {'@': 603}), 64: (1, {'@': 603}), 66: (1, {'@': 603}), 67: (1, {'@': 603}), 34: (1, {'@': 603}), 36: (1, {'@': 603}), 37: (1, {'@': 603}), 68: (1, {'@': 603}), 38: (1, {'@': 603}), 69: (1, {'@': 603}), 70: (1, {'@': 603}), 71: (1, {'@': 603}), 40: (1, {'@': 603}), 41: (1, {'@': 603}), 73: (1, {'@': 603}), 74: (1, {'@': 603}), 75: (1, {'@': 603})}, 686: {57: (1, {'@': 782}), 60: (1, {'@': 782})}, 687: {112: (1, {'@': 1716}), 441: (1, {'@': 1716}), 89: (1, {'@': 1716}), 442: (1, {'@': 1716}), 107: (1, {'@': 1716}), 443: (1, {'@': 1716}), 60: (1, {'@': 1716})}, 688: {177: (1, {'@': 601}), 7: (1, {'@': 601}), 22: (1, {'@': 601}), 60: (1, {'@': 601}), 126: (1, {'@': 601}), 48: (1, {'@': 601}), 72: (1, {'@': 601}), 178: (1, {'@': 601}), 179: (1, {'@': 601}), 49: (1, {'@': 601}), 57: (1, {'@': 601}), 43: (1, {'@': 601}), 1: (1, {'@': 601}), 2: (1, {'@': 601}), 44: (1, {'@': 601}), 45: (1, {'@': 601}), 47: (1, {'@': 601}), 4: (1, {'@': 601}), 50: (1, {'@': 601}), 51: (1, {'@': 601}), 6: (1, {'@': 601}), 52: (1, {'@': 601}), 8: (1, {'@': 601}), 9: (1, {'@': 601}), 53: (1, {'@': 601}), 11: (1, {'@': 601}), 54: (1, {'@': 601}), 55: (1, {'@': 601}), 15: (1, {'@': 601}), 17: (1, {'@': 601}), 18: (1, {'@': 601}), 58: (1, {'@': 601}), 59: (1, {'@': 601}), 21: (1, {'@': 601}), 61: (1, {'@': 601}), 62: (1, {'@': 601}), 23: (1, {'@': 601}), 25: (1, {'@': 601}), 26: (1, {'@': 601}), 63: (1, {'@': 601}), 27: (1, {'@': 601}), 28: (1, {'@': 601}), 29: (1, {'@': 601}), 30: (1, {'@': 601}), 31: (1, {'@': 601}), 33: (1, {'@': 601}), 64: (1, {'@': 601}), 66: (1, {'@': 601}), 67: (1, {'@': 601}), 34: (1, {'@': 601}), 36: (1, {'@': 601}), 37: (1, {'@': 601}), 68: (1, {'@': 601}), 38: (1, {'@': 601}), 69: (1, {'@': 601}), 70: (1, {'@': 601}), 71: (1, {'@': 601}), 40: (1, {'@': 601}), 41: (1, {'@': 601}), 73: (1, {'@': 601}), 74: (1, {'@': 601}), 75: (1, {'@': 601})}, 689: {146: (0, 1238)}, 690: {177: (1, {'@': 607}), 7: (1, {'@': 607}), 22: (1, {'@': 607}), 60: (1, {'@': 607}), 126: (1, {'@': 607}), 48: (1, {'@': 607}), 72: (1, {'@': 607}), 178: (1, {'@': 607}), 179: (1, {'@': 607}), 49: (1, {'@': 607}), 57: (1, {'@': 607})}, 691: {146: (1, {'@': 1056})}, 692: {500: (1, {'@': 1622}), 60: (1, {'@': 1622}), 501: (1, {'@': 1622}), 126: (1, {'@': 1622}), 57: (1, {'@': 1622})}, 693: {146: (0, 2024)}, 694: {177: (1, {'@': 605}), 7: (1, {'@': 605}), 22: (1, {'@': 605}), 60: (1, {'@': 605}), 126: (1, {'@': 605}), 48: (1, {'@': 605}), 72: (1, {'@': 605}), 178: (1, {'@': 605}), 179: (1, {'@': 605}), 49: (1, {'@': 605}), 57: (1, {'@': 605})}, 695: {146: (0, 1227)}, 696: {112: (1, {'@': 1711}), 89: (1, {'@': 1711}), 97: (1, {'@': 1711}), 107: (1, {'@': 1711}), 126: (1, {'@': 1711}), 146: (1, {'@': 1711}), 60: (1, {'@': 1711})}, 697: {33: (1, {'@': 1662}), 2: (1, {'@': 1662}), 6: (1, {'@': 1662}), 52: (1, {'@': 1662}), 8: (1, {'@': 1662}), 44: (1, {'@': 1662}), 61: (1, {'@': 1662}), 53: (1, {'@': 1662}), 126: (1, {'@': 1662}), 60: (1, {'@': 1662}), 37: (1, {'@': 1662}), 71: (1, {'@': 1662}), 63: (1, {'@': 1662}), 55: (1, {'@': 1662}), 28: (1, {'@': 1662}), 57: (1, {'@': 1662})}, 698: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 1687)}, 699: {60: (0, 637)}, 700: {204: (0, 1972), 165: (0, 2211), 479: (0, 2215), 53: (0, 387), 33: (0, 383), 63: (0, 2218), 164: (0, 2221), 44: (0, 358), 2: (0, 2225), 55: (0, 2229), 185: (0, 2239), 481: (0, 2240), 8: (0, 1510), 52: (0, 1498), 28: (0, 33), 210: (0, 2244), 61: (0, 25), 482: (0, 2248), 483: (0, 2251), 290: (0, 2257), 480: (0, 1241), 37: (0, 1828), 71: (0, 2263), 6: (0, 20), 183: (0, 2267), 292: (0, 2274), 172: (0, 2278)}, 701: {60: (0, 536)}, 702: {1: (1, {'@': 985}), 6: (1, {'@': 985}), 60: (1, {'@': 985}), 61: (1, {'@': 985}), 126: (1, {'@': 985}), 45: (1, {'@': 985}), 38: (1, {'@': 985}), 26: (1, {'@': 985}), 27: (1, {'@': 985}), 28: (1, {'@': 985}), 57: (1, {'@': 985}), 43: (1, {'@': 985}), 2: (1, {'@': 985}), 44: (1, {'@': 985}), 47: (1, {'@': 985}), 48: (1, {'@': 985}), 4: (1, {'@': 985}), 49: (1, {'@': 985}), 50: (1, {'@': 985}), 51: (1, {'@': 985}), 52: (1, {'@': 985}), 8: (1, {'@': 985}), 7: (1, {'@': 985}), 9: (1, {'@': 985}), 53: (1, {'@': 985}), 11: (1, {'@': 985}), 54: (1, {'@': 985}), 55: (1, {'@': 985}), 15: (1, {'@': 985}), 17: (1, {'@': 985}), 18: (1, {'@': 985}), 58: (1, {'@': 985}), 59: (1, {'@': 985}), 21: (1, {'@': 985}), 22: (1, {'@': 985}), 62: (1, {'@': 985}), 23: (1, {'@': 985}), 25: (1, {'@': 985}), 63: (1, {'@': 985}), 29: (1, {'@': 985}), 30: (1, {'@': 985}), 31: (1, {'@': 985}), 33: (1, {'@': 985}), 64: (1, {'@': 985}), 66: (1, {'@': 985}), 67: (1, {'@': 985}), 34: (1, {'@': 985}), 36: (1, {'@': 985}), 37: (1, {'@': 985}), 68: (1, {'@': 985}), 69: (1, {'@': 985}), 70: (1, {'@': 985}), 71: (1, {'@': 985}), 40: (1, {'@': 985}), 72: (1, {'@': 985}), 41: (1, {'@': 985}), 73: (1, {'@': 985}), 74: (1, {'@': 985}), 75: (1, {'@': 985})}, 703: {60: (0, 560)}, 704: {57: (1, {'@': 627}), 60: (1, {'@': 627}), 6: (1, {'@': 627}), 7: (1, {'@': 627}), 61: (1, {'@': 627}), 126: (1, {'@': 627}), 45: (1, {'@': 627}), 37: (1, {'@': 627}), 38: (1, {'@': 627}), 47: (1, {'@': 627}), 26: (1, {'@': 627}), 27: (1, {'@': 627}), 4: (1, {'@': 627}), 28: (1, {'@': 627}), 50: (1, {'@': 627}), 53: (1, {'@': 627}), 67: (1, {'@': 627}), 29: (1, {'@': 627}), 30: (1, {'@': 627}), 15: (1, {'@': 627}), 268: (1, {'@': 627}), 270: (1, {'@': 627}), 266: (1, {'@': 627}), 43: (1, {'@': 627}), 1: (1, {'@': 627}), 2: (1, {'@': 627}), 44: (1, {'@': 627}), 48: (1, {'@': 627}), 49: (1, {'@': 627}), 51: (1, {'@': 627}), 52: (1, {'@': 627}), 8: (1, {'@': 627}), 9: (1, {'@': 627}), 11: (1, {'@': 627}), 54: (1, {'@': 627}), 55: (1, {'@': 627}), 17: (1, {'@': 627}), 18: (1, {'@': 627}), 58: (1, {'@': 627}), 59: (1, {'@': 627}), 21: (1, {'@': 627}), 22: (1, {'@': 627}), 62: (1, {'@': 627}), 23: (1, {'@': 627}), 25: (1, {'@': 627}), 63: (1, {'@': 627}), 31: (1, {'@': 627}), 33: (1, {'@': 627}), 64: (1, {'@': 627}), 66: (1, {'@': 627}), 34: (1, {'@': 627}), 36: (1, {'@': 627}), 68: (1, {'@': 627}), 69: (1, {'@': 627}), 70: (1, {'@': 627}), 71: (1, {'@': 627}), 40: (1, {'@': 627}), 72: (1, {'@': 627}), 41: (1, {'@': 627}), 73: (1, {'@': 627}), 74: (1, {'@': 627}), 75: (1, {'@': 627})}, 705: {60: (0, 518)}, 706: {146: (1, {'@': 863})}, 707: {60: (0, 1207)}, 708: {112: (1, {'@': 1313}), 57: (1, {'@': 1313}), 60: (1, {'@': 1313}), 147: (1, {'@': 1313}), 126: (1, {'@': 1313}), 148: (1, {'@': 1313}), 149: (1, {'@': 1313}), 150: (1, {'@': 1313}), 151: (1, {'@': 1313}), 152: (1, {'@': 1313}), 153: (1, {'@': 1313}), 154: (1, {'@': 1313}), 155: (1, {'@': 1313}), 156: (1, {'@': 1313}), 157: (1, {'@': 1313}), 158: (1, {'@': 1313}), 159: (1, {'@': 1313}), 160: (1, {'@': 1313})}, 709: {60: (0, 533)}, 710: {60: (1, {'@': 1736}), 126: (1, {'@': 1736}), 146: (1, {'@': 1736})}, 711: {80: (0, 2414), 81: (0, 2295), 194: (0, 1252), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 712: {60: (0, 530)}, 713: {60: (0, 1655)}, 714: {60: (1, {'@': 1240}), 57: (1, {'@': 1240})}, 715: {1: (1, {'@': 986}), 6: (1, {'@': 986}), 60: (1, {'@': 986}), 61: (1, {'@': 986}), 126: (1, {'@': 986}), 45: (1, {'@': 986}), 38: (1, {'@': 986}), 26: (1, {'@': 986}), 27: (1, {'@': 986}), 28: (1, {'@': 986}), 57: (1, {'@': 986}), 43: (1, {'@': 986}), 2: (1, {'@': 986}), 44: (1, {'@': 986}), 47: (1, {'@': 986}), 48: (1, {'@': 986}), 4: (1, {'@': 986}), 49: (1, {'@': 986}), 50: (1, {'@': 986}), 51: (1, {'@': 986}), 52: (1, {'@': 986}), 8: (1, {'@': 986}), 7: (1, {'@': 986}), 9: (1, {'@': 986}), 53: (1, {'@': 986}), 11: (1, {'@': 986}), 54: (1, {'@': 986}), 55: (1, {'@': 986}), 15: (1, {'@': 986}), 17: (1, {'@': 986}), 18: (1, {'@': 986}), 58: (1, {'@': 986}), 59: (1, {'@': 986}), 21: (1, {'@': 986}), 22: (1, {'@': 986}), 62: (1, {'@': 986}), 23: (1, {'@': 986}), 25: (1, {'@': 986}), 63: (1, {'@': 986}), 29: (1, {'@': 986}), 30: (1, {'@': 986}), 31: (1, {'@': 986}), 33: (1, {'@': 986}), 64: (1, {'@': 986}), 66: (1, {'@': 986}), 67: (1, {'@': 986}), 34: (1, {'@': 986}), 36: (1, {'@': 986}), 37: (1, {'@': 986}), 68: (1, {'@': 986}), 69: (1, {'@': 986}), 70: (1, {'@': 986}), 71: (1, {'@': 986}), 40: (1, {'@': 986}), 72: (1, {'@': 986}), 41: (1, {'@': 986}), 73: (1, {'@': 986}), 74: (1, {'@': 986}), 75: (1, {'@': 986})}, 716: {60: (1, {'@': 1231}), 57: (1, {'@': 1231})}, 717: {112: (1, {'@': 1310}), 57: (1, {'@': 1310}), 60: (1, {'@': 1310}), 147: (1, {'@': 1310}), 126: (1, {'@': 1310}), 148: (1, {'@': 1310}), 149: (1, {'@': 1310}), 150: (1, {'@': 1310}), 151: (1, {'@': 1310}), 152: (1, {'@': 1310}), 153: (1, {'@': 1310}), 154: (1, {'@': 1310}), 155: (1, {'@': 1310}), 156: (1, {'@': 1310}), 157: (1, {'@': 1310}), 158: (1, {'@': 1310}), 159: (1, {'@': 1310}), 160: (1, {'@': 1310})}, 718: {43: (1, {'@': 1615}), 1: (1, {'@': 1615}), 2: (1, {'@': 1615}), 44: (1, {'@': 1615}), 45: (1, {'@': 1615}), 47: (1, {'@': 1615}), 48: (1, {'@': 1615}), 4: (1, {'@': 1615}), 49: (1, {'@': 1615}), 50: (1, {'@': 1615}), 51: (1, {'@': 1615}), 6: (1, {'@': 1615}), 52: (1, {'@': 1615}), 8: (1, {'@': 1615}), 7: (1, {'@': 1615}), 9: (1, {'@': 1615}), 53: (1, {'@': 1615}), 11: (1, {'@': 1615}), 54: (1, {'@': 1615}), 55: (1, {'@': 1615}), 15: (1, {'@': 1615}), 17: (1, {'@': 1615}), 57: (1, {'@': 1615}), 18: (1, {'@': 1615}), 58: (1, {'@': 1615}), 59: (1, {'@': 1615}), 21: (1, {'@': 1615}), 22: (1, {'@': 1615}), 60: (1, {'@': 1615}), 61: (1, {'@': 1615}), 126: (1, {'@': 1615}), 62: (1, {'@': 1615}), 23: (1, {'@': 1615}), 25: (1, {'@': 1615}), 26: (1, {'@': 1615}), 63: (1, {'@': 1615}), 27: (1, {'@': 1615}), 28: (1, {'@': 1615}), 29: (1, {'@': 1615}), 30: (1, {'@': 1615}), 31: (1, {'@': 1615}), 33: (1, {'@': 1615}), 64: (1, {'@': 1615}), 66: (1, {'@': 1615}), 67: (1, {'@': 1615}), 34: (1, {'@': 1615}), 36: (1, {'@': 1615}), 37: (1, {'@': 1615}), 68: (1, {'@': 1615}), 38: (1, {'@': 1615}), 69: (1, {'@': 1615}), 70: (1, {'@': 1615}), 71: (1, {'@': 1615}), 40: (1, {'@': 1615}), 72: (1, {'@': 1615}), 41: (1, {'@': 1615}), 73: (1, {'@': 1615}), 74: (1, {'@': 1615}), 75: (1, {'@': 1615})}, 719: {126: (0, 723), 536: (0, 670), 537: (0, 1755)}, 720: {60: (1, {'@': 1735}), 126: (1, {'@': 1735}), 146: (1, {'@': 1735})}, 721: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 1254)}, 722: {78: (0, 52), 32: (0, 61), 96: (0, 63), 119: (0, 64), 315: (0, 66), 316: (0, 67), 317: (0, 68), 318: (0, 69), 99: (0, 70), 91: (0, 71), 19: (0, 72), 319: (0, 74), 320: (0, 75), 321: (0, 76), 322: (0, 77), 323: (0, 78), 16: (0, 79), 13: (0, 80), 118: (0, 81), 115: (0, 86), 105: (0, 87), 324: (0, 89), 325: (0, 90), 122: (0, 91), 85: (0, 93), 39: (0, 95), 259: (0, 97), 326: (0, 99), 327: (0, 100), 114: (0, 101), 328: (0, 103), 124: (0, 104), 84: (0, 105), 102: (0, 106), 3: (0, 107), 113: (0, 109), 65: (0, 110), 90: (0, 112), 94: (0, 113), 329: (0, 115), 95: (0, 116), 330: (0, 117), 331: (0, 118), 0: (0, 119), 110: (0, 1461), 332: (0, 1464), 46: (0, 1467), 333: (0, 1475), 93: (0, 1477), 24: (0, 1485), 111: (0, 1493), 120: (0, 1499), 98: (0, 1503), 117: (0, 1504), 56: (0, 1511), 334: (0, 1514), 14: (0, 1515), 5: (0, 1526), 335: (0, 1533), 108: (0, 1536), 336: (0, 1539), 20: (0, 1541), 337: (0, 1547), 79: (0, 1550), 10: (0, 1552), 338: (0, 1559), 77: (0, 1563), 339: (0, 1564), 340: (0, 1568), 83: (0, 1570), 103: (0, 1572), 341: (0, 1586), 342: (0, 1588), 123: (0, 1591), 344: (0, 1593), 345: (0, 1595), 346: (0, 1597), 347: (0, 1599), 348: (0, 1601), 82: (0, 1605), 349: (0, 1613), 350: (0, 1615), 100: (0, 1618), 116: (0, 1630), 106: (0, 1634), 351: (0, 1645), 352: (0, 1647), 353: (0, 1649), 354: (0, 1651), 88: (0, 1653), 355: (0, 1662), 356: (0, 1663), 35: (0, 1664), 92: (0, 1672), 343: (0, 713), 357: (0, 1682), 12: (0, 1684), 87: (0, 1692), 358: (0, 1700), 359: (0, 1702), 360: (0, 1705), 361: (0, 1707), 362: (0, 1709), 42: (0, 1712), 363: (0, 1720), 364: (0, 1722), 365: (0, 1725), 366: (0, 1726), 109: (0, 1729), 367: (0, 1735), 368: (0, 1738), 369: (0, 1740), 370: (0, 1744), 371: (0, 1745), 372: (0, 1748), 373: (0, 1749)}, 723: {537: (0, 1942), 536: (0, 670)}, 724: {112: (1, {'@': 1273}), 57: (1, {'@': 1273}), 60: (1, {'@': 1273}), 147: (1, {'@': 1273}), 126: (1, {'@': 1273}), 148: (1, {'@': 1273}), 149: (1, {'@': 1273}), 150: (1, {'@': 1273}), 151: (1, {'@': 1273}), 152: (1, {'@': 1273}), 153: (1, {'@': 1273}), 154: (1, {'@': 1273}), 155: (1, {'@': 1273}), 156: (1, {'@': 1273}), 157: (1, {'@': 1273}), 158: (1, {'@': 1273}), 159: (1, {'@': 1273}), 160: (1, {'@': 1273})}, 725: {60: (0, 617)}, 726: {524: (0, 737), 525: (0, 1953)}, 727: {80: (0, 2414), 81: (0, 2295), 194: (0, 1256), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 728: {60: (1, {'@': 496}), 57: (1, {'@': 496})}, 729: {6: (1, {'@': 1478}), 60: (1, {'@': 1478}), 7: (1, {'@': 1478}), 61: (1, {'@': 1478}), 126: (1, {'@': 1478}), 28: (1, {'@': 1478}), 17: (1, {'@': 1478}), 57: (1, {'@': 1478}), 59: (1, {'@': 1478}), 21: (1, {'@': 1478}), 22: (1, {'@': 1478}), 44: (1, {'@': 1478}), 62: (1, {'@': 1478}), 23: (1, {'@': 1478}), 25: (1, {'@': 1478}), 49: (1, {'@': 1478}), 33: (1, {'@': 1478}), 53: (1, {'@': 1478}), 69: (1, {'@': 1478}), 40: (1, {'@': 1478}), 41: (1, {'@': 1478}), 75: (1, {'@': 1478}), 73: (1, {'@': 1478}), 45: (1, {'@': 1478}), 37: (1, {'@': 1478}), 38: (1, {'@': 1478}), 47: (1, {'@': 1478}), 26: (1, {'@': 1478}), 27: (1, {'@': 1478}), 4: (1, {'@': 1478}), 50: (1, {'@': 1478}), 174: (1, {'@': 1478}), 175: (1, {'@': 1478}), 176: (1, {'@': 1478}), 177: (1, {'@': 1478}), 48: (1, {'@': 1478}), 72: (1, {'@': 1478}), 178: (1, {'@': 1478}), 179: (1, {'@': 1478}), 43: (1, {'@': 1478}), 1: (1, {'@': 1478}), 2: (1, {'@': 1478}), 51: (1, {'@': 1478}), 52: (1, {'@': 1478}), 8: (1, {'@': 1478}), 9: (1, {'@': 1478}), 11: (1, {'@': 1478}), 54: (1, {'@': 1478}), 55: (1, {'@': 1478}), 15: (1, {'@': 1478}), 18: (1, {'@': 1478}), 58: (1, {'@': 1478}), 63: (1, {'@': 1478}), 29: (1, {'@': 1478}), 30: (1, {'@': 1478}), 31: (1, {'@': 1478}), 64: (1, {'@': 1478}), 66: (1, {'@': 1478}), 67: (1, {'@': 1478}), 34: (1, {'@': 1478}), 36: (1, {'@': 1478}), 68: (1, {'@': 1478}), 70: (1, {'@': 1478}), 71: (1, {'@': 1478}), 74: (1, {'@': 1478})}, 730: {60: (0, 636)}, 731: {538: (0, 1743), 539: (0, 739), 126: (0, 1768), 57: (1, {'@': 499}), 60: (1, {'@': 499})}, 732: {146: (1, {'@': 559})}, 733: {60: (0, 566)}, 734: {126: (1, {'@': 1450})}, 735: {6: (1, {'@': 910}), 60: (1, {'@': 910}), 7: (1, {'@': 910}), 61: (1, {'@': 910}), 126: (1, {'@': 910}), 28: (1, {'@': 910}), 17: (1, {'@': 910}), 57: (1, {'@': 910}), 43: (1, {'@': 910}), 1: (1, {'@': 910}), 2: (1, {'@': 910}), 44: (1, {'@': 910}), 45: (1, {'@': 910}), 47: (1, {'@': 910}), 48: (1, {'@': 910}), 4: (1, {'@': 910}), 49: (1, {'@': 910}), 50: (1, {'@': 910}), 51: (1, {'@': 910}), 52: (1, {'@': 910}), 8: (1, {'@': 910}), 9: (1, {'@': 910}), 53: (1, {'@': 910}), 11: (1, {'@': 910}), 54: (1, {'@': 910}), 55: (1, {'@': 910}), 15: (1, {'@': 910}), 18: (1, {'@': 910}), 58: (1, {'@': 910}), 59: (1, {'@': 910}), 21: (1, {'@': 910}), 22: (1, {'@': 910}), 62: (1, {'@': 910}), 23: (1, {'@': 910}), 25: (1, {'@': 910}), 26: (1, {'@': 910}), 63: (1, {'@': 910}), 27: (1, {'@': 910}), 29: (1, {'@': 910}), 30: (1, {'@': 910}), 31: (1, {'@': 910}), 33: (1, {'@': 910}), 64: (1, {'@': 910}), 66: (1, {'@': 910}), 67: (1, {'@': 910}), 34: (1, {'@': 910}), 36: (1, {'@': 910}), 37: (1, {'@': 910}), 68: (1, {'@': 910}), 38: (1, {'@': 910}), 69: (1, {'@': 910}), 70: (1, {'@': 910}), 71: (1, {'@': 910}), 40: (1, {'@': 910}), 72: (1, {'@': 910}), 41: (1, {'@': 910}), 73: (1, {'@': 910}), 74: (1, {'@': 910}), 75: (1, {'@': 910})}, 736: {80: (0, 2434), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 399: (0, 629)}, 737: {112: (0, 1737)}, 738: {60: (1, {'@': 1317}), 57: (1, {'@': 1317})}, 739: {112: (0, 1752)}, 740: {540: (0, 1233), 541: (0, 1024), 531: (0, 262), 542: (0, 1023)}, 741: {377: (0, 184), 376: (0, 528), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 255: (0, 1221), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 379: (0, 540), 117: (0, 804), 86: (0, 543), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 42: (0, 858), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 380: (0, 1402), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 381: (0, 547), 90: (0, 853), 3: (0, 855), 123: (0, 856), 256: (0, 550), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 742: {144: (0, 2316), 145: (0, 1262)}, 743: {60: (0, 690)}, 744: {60: (1, {'@': 1729}), 126: (1, {'@': 1729}), 146: (1, {'@': 1729})}, 745: {500: (1, {'@': 1620}), 60: (1, {'@': 1620}), 501: (1, {'@': 1620}), 126: (1, {'@': 1620}), 57: (1, {'@': 1620})}, 746: {59: (1, {'@': 1617}), 60: (1, {'@': 1617}), 57: (1, {'@': 1617})}, 747: {60: (0, 619)}, 748: {144: (0, 1246)}, 749: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 86: (0, 680), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 194: (0, 676), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 750: {60: (1, {'@': 1323}), 57: (1, {'@': 1323})}, 751: {515: (1, {'@': 1630}), 517: (1, {'@': 1630}), 60: (1, {'@': 1630}), 126: (1, {'@': 1630}), 514: (1, {'@': 1630}), 57: (1, {'@': 1630})}, 752: {60: (1, {'@': 1315}), 57: (1, {'@': 1315})}, 753: {80: (0, 2434), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 399: (0, 747)}, 754: {515: (1, {'@': 1627}), 517: (1, {'@': 1627}), 60: (1, {'@': 1627}), 126: (1, {'@': 1627}), 514: (1, {'@': 1627}), 57: (1, {'@': 1627})}, 755: {60: (1, {'@': 1319}), 57: (1, {'@': 1319})}, 756: {60: (1, {'@': 563}), 57: (1, {'@': 563})}, 757: {60: (1, {'@': 1321}), 57: (1, {'@': 1321})}, 758: {60: (0, 1041)}, 759: {512: (0, 1806), 513: (0, 1992), 514: (0, 1981), 515: (0, 1993), 517: (0, 2030), 516: (0, 1999), 519: (0, 2021)}, 760: {60: (1, {'@': 1325}), 57: (1, {'@': 1325})}, 761: {60: (0, 645)}, 762: {112: (1, {'@': 1304}), 57: (1, {'@': 1304}), 60: (1, {'@': 1304}), 147: (1, {'@': 1304}), 126: (1, {'@': 1304}), 148: (1, {'@': 1304}), 149: (1, {'@': 1304}), 150: (1, {'@': 1304}), 151: (1, {'@': 1304}), 152: (1, {'@': 1304}), 153: (1, {'@': 1304}), 154: (1, {'@': 1304}), 155: (1, {'@': 1304}), 156: (1, {'@': 1304}), 157: (1, {'@': 1304}), 158: (1, {'@': 1304}), 159: (1, {'@': 1304}), 160: (1, {'@': 1304})}, 763: {112: (0, 1787)}, 764: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 194: (0, 1264), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 765: {501: (0, 1985), 500: (0, 2010), 527: (0, 2231), 528: (0, 2454), 529: (0, 692), 126: (0, 666), 57: (1, {'@': 539}), 60: (1, {'@': 539})}, 766: {60: (0, 688)}, 767: {60: (0, 1781)}, 768: {115: (0, 44), 77: (0, 17), 108: (0, 400), 86: (0, 1260), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 769: {126: (0, 1805), 543: (0, 1823), 60: (1, {'@': 580})}, 770: {144: (0, 2316), 145: (0, 2243)}, 771: {60: (0, 694)}, 772: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 1268)}, 773: {60: (0, 715)}, 774: {146: (0, 2190)}, 775: {501: (0, 1985), 500: (0, 2010), 527: (0, 2231), 529: (0, 634), 528: (0, 2454)}, 776: {146: (1, {'@': 575}), 126: (1, {'@': 575})}, 777: {177: (1, {'@': 606}), 7: (1, {'@': 606}), 22: (1, {'@': 606}), 60: (1, {'@': 606}), 126: (1, {'@': 606}), 48: (1, {'@': 606}), 72: (1, {'@': 606}), 178: (1, {'@': 606}), 179: (1, {'@': 606}), 49: (1, {'@': 606}), 57: (1, {'@': 606})}, 778: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 86: (0, 683), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 194: (0, 705), 85: (0, 816), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 118: (0, 819), 10: (0, 826), 100: (0, 817), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 779: {146: (1, {'@': 574}), 126: (1, {'@': 574})}, 780: {126: (1, {'@': 399}), 146: (1, {'@': 399}), 60: (1, {'@': 399})}, 781: {126: (1, {'@': 404}), 146: (1, {'@': 404}), 60: (1, {'@': 404})}, 782: {544: (0, 1053), 545: (0, 1266)}, 783: {126: (1, {'@': 392}), 146: (1, {'@': 392}), 60: (1, {'@': 392})}, 784: {6: (1, {'@': 1665}), 60: (1, {'@': 1665}), 7: (1, {'@': 1665}), 61: (1, {'@': 1665}), 126: (1, {'@': 1665}), 28: (1, {'@': 1665}), 17: (1, {'@': 1665}), 57: (1, {'@': 1665})}, 785: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 1280), 112: (0, 2376), 97: (0, 2370)}, 786: {126: (1, {'@': 368}), 146: (1, {'@': 368}), 60: (1, {'@': 368})}, 787: {126: (1, {'@': 402}), 146: (1, {'@': 402}), 60: (1, {'@': 402})}, 788: {107: (0, 2409), 112: (0, 2376), 81: (0, 2295), 80: (0, 2414), 194: (0, 1223), 97: (0, 2370), 89: (0, 2384), 428: (0, 1305)}, 789: {126: (1, {'@': 375}), 146: (1, {'@': 375}), 60: (1, {'@': 375})}, 790: {144: (0, 2316), 145: (0, 1270)}, 791: {126: (1, {'@': 381}), 146: (1, {'@': 381}), 60: (1, {'@': 381})}, 792: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 1288), 112: (0, 2376), 97: (0, 2370)}, 793: {126: (1, {'@': 362}), 146: (1, {'@': 362}), 60: (1, {'@': 362})}, 794: {144: (0, 2316), 145: (0, 1272)}, 795: {126: (0, 2594), 53: (0, 387), 172: (0, 2222), 60: (1, {'@': 1364}), 57: (1, {'@': 1364})}, 796: {107: (0, 2409), 112: (0, 2376), 81: (0, 2295), 80: (0, 2414), 194: (0, 1223), 428: (0, 1294), 97: (0, 2370), 89: (0, 2384)}, 797: {60: (1, {'@': 495}), 57: (1, {'@': 495})}, 798: {6: (1, {'@': 1469}), 60: (1, {'@': 1469}), 7: (1, {'@': 1469}), 61: (1, {'@': 1469}), 126: (1, {'@': 1469}), 28: (1, {'@': 1469}), 17: (1, {'@': 1469}), 57: (1, {'@': 1469}), 59: (1, {'@': 1469}), 21: (1, {'@': 1469}), 22: (1, {'@': 1469}), 44: (1, {'@': 1469}), 62: (1, {'@': 1469}), 23: (1, {'@': 1469}), 25: (1, {'@': 1469}), 49: (1, {'@': 1469}), 33: (1, {'@': 1469}), 53: (1, {'@': 1469}), 69: (1, {'@': 1469}), 40: (1, {'@': 1469}), 41: (1, {'@': 1469}), 75: (1, {'@': 1469}), 73: (1, {'@': 1469}), 45: (1, {'@': 1469}), 37: (1, {'@': 1469}), 38: (1, {'@': 1469}), 47: (1, {'@': 1469}), 26: (1, {'@': 1469}), 27: (1, {'@': 1469}), 4: (1, {'@': 1469}), 50: (1, {'@': 1469}), 43: (1, {'@': 1469}), 64: (1, {'@': 1469}), 34: (1, {'@': 1469}), 54: (1, {'@': 1469}), 74: (1, {'@': 1469}), 18: (1, {'@': 1469}), 58: (1, {'@': 1469}), 66: (1, {'@': 1469}), 1: (1, {'@': 1469}), 2: (1, {'@': 1469}), 63: (1, {'@': 1469}), 52: (1, {'@': 1469}), 8: (1, {'@': 1469}), 71: (1, {'@': 1469}), 55: (1, {'@': 1469}), 48: (1, {'@': 1469}), 51: (1, {'@': 1469}), 9: (1, {'@': 1469}), 11: (1, {'@': 1469}), 15: (1, {'@': 1469}), 29: (1, {'@': 1469}), 30: (1, {'@': 1469}), 31: (1, {'@': 1469}), 67: (1, {'@': 1469}), 36: (1, {'@': 1469}), 68: (1, {'@': 1469}), 70: (1, {'@': 1469}), 72: (1, {'@': 1469}), 469: (1, {'@': 1469})}, 799: {126: (1, {'@': 367}), 146: (1, {'@': 367}), 60: (1, {'@': 367})}, 800: {126: (1, {'@': 401}), 146: (1, {'@': 401}), 60: (1, {'@': 401})}, 801: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 546: (0, 1277), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 86: (0, 1092), 96: (0, 789), 547: (0, 1102), 82: (0, 791), 98: (0, 793), 110: (0, 799), 548: (0, 1108), 19: (0, 800), 13: (0, 802), 117: (0, 804), 549: (0, 1093), 83: (0, 809), 32: (0, 807), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 550: (0, 1109), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 802: {126: (1, {'@': 385}), 146: (1, {'@': 385}), 60: (1, {'@': 385})}, 803: {133: (1, {'@': 698}), 130: (1, {'@': 698}), 141: (1, {'@': 698}), 60: (1, {'@': 698}), 129: (1, {'@': 698}), 126: (1, {'@': 698}), 134: (1, {'@': 698}), 57: (1, {'@': 698}), 132: (1, {'@': 698}), 139: (1, {'@': 698})}, 804: {126: (1, {'@': 410}), 146: (1, {'@': 410}), 60: (1, {'@': 410})}, 805: {126: (0, 1274), 146: (1, {'@': 1470})}, 806: {107: (0, 2409), 112: (0, 2376), 81: (0, 2295), 80: (0, 2414), 194: (0, 1223), 97: (0, 2370), 428: (0, 1299), 89: (0, 2384)}, 807: {126: (1, {'@': 387}), 146: (1, {'@': 387}), 60: (1, {'@': 387})}, 808: {428: (0, 1291), 107: (0, 2409), 112: (0, 2376), 81: (0, 2295), 80: (0, 2414), 194: (0, 1223), 97: (0, 2370), 89: (0, 2384)}, 809: {126: (1, {'@': 361}), 146: (1, {'@': 361}), 60: (1, {'@': 361})}, 810: {107: (0, 2409), 112: (0, 2376), 81: (0, 2295), 80: (0, 2414), 194: (0, 1223), 97: (0, 2370), 89: (0, 2384), 428: (0, 1302)}, 811: {126: (1, {'@': 371}), 146: (1, {'@': 371}), 60: (1, {'@': 371})}, 812: {126: (1, {'@': 366}), 146: (1, {'@': 366}), 60: (1, {'@': 366})}, 813: {107: (0, 2409), 112: (0, 2376), 81: (0, 2295), 80: (0, 2414), 194: (0, 1223), 97: (0, 2370), 89: (0, 2384), 428: (0, 1303)}, 814: {126: (1, {'@': 403}), 146: (1, {'@': 403}), 60: (1, {'@': 403})}, 815: {428: (0, 1307), 107: (0, 2409), 112: (0, 2376), 81: (0, 2295), 80: (0, 2414), 194: (0, 1223), 97: (0, 2370), 89: (0, 2384)}, 816: {126: (1, {'@': 406}), 146: (1, {'@': 406}), 60: (1, {'@': 406})}, 817: {126: (1, {'@': 416}), 146: (1, {'@': 416}), 60: (1, {'@': 416})}, 818: {428: (0, 1308), 107: (0, 2409), 112: (0, 2376), 81: (0, 2295), 80: (0, 2414), 194: (0, 1223), 97: (0, 2370), 89: (0, 2384)}, 819: {126: (1, {'@': 415}), 146: (1, {'@': 415}), 60: (1, {'@': 415})}, 820: {57: (1, {'@': 1372}), 60: (1, {'@': 1372}), 126: (1, {'@': 1372}), 263: (1, {'@': 1372}), 260: (1, {'@': 1372}), 299: (1, {'@': 1372}), 452: (1, {'@': 1372}), 400: (1, {'@': 1372})}, 821: {126: (1, {'@': 411}), 146: (1, {'@': 411}), 60: (1, {'@': 411})}, 822: {126: (1, {'@': 395}), 146: (1, {'@': 395}), 60: (1, {'@': 395})}, 823: {126: (1, {'@': 364}), 146: (1, {'@': 364}), 60: (1, {'@': 364})}, 824: {551: (0, 1141), 90: (0, 1128), 106: (0, 1144), 114: (0, 1132), 96: (0, 1152), 103: (0, 1125), 552: (0, 1126), 87: (0, 1134), 82: (0, 1156), 553: (0, 1310)}, 825: {126: (1, {'@': 377}), 146: (1, {'@': 377}), 60: (1, {'@': 377})}, 826: {126: (1, {'@': 405}), 146: (1, {'@': 405}), 60: (1, {'@': 405})}, 827: {133: (1, {'@': 692}), 130: (1, {'@': 692}), 141: (1, {'@': 692}), 60: (1, {'@': 692}), 129: (1, {'@': 692}), 126: (1, {'@': 692}), 134: (1, {'@': 692}), 57: (1, {'@': 692}), 132: (1, {'@': 692}), 139: (1, {'@': 692})}, 828: {126: (1, {'@': 376}), 146: (1, {'@': 376}), 60: (1, {'@': 376})}, 829: {133: (1, {'@': 701}), 130: (1, {'@': 701}), 141: (1, {'@': 701}), 60: (1, {'@': 701}), 129: (1, {'@': 701}), 126: (1, {'@': 701}), 134: (1, {'@': 701}), 57: (1, {'@': 701}), 132: (1, {'@': 701}), 139: (1, {'@': 701})}, 830: {126: (1, {'@': 374}), 146: (1, {'@': 374}), 60: (1, {'@': 374})}, 831: {126: (0, 1284), 60: (1, {'@': 1374})}, 832: {126: (1, {'@': 382}), 146: (1, {'@': 382}), 60: (1, {'@': 382})}, 833: {90: (0, 1128), 106: (0, 1144), 114: (0, 1132), 551: (0, 1229), 96: (0, 1152), 552: (0, 1126), 103: (0, 1125), 87: (0, 1134), 82: (0, 1156)}, 834: {126: (1, {'@': 384}), 146: (1, {'@': 384}), 60: (1, {'@': 384})}, 835: {230: (1, {'@': 734}), 60: (1, {'@': 734}), 235: (1, {'@': 734}), 240: (1, {'@': 734}), 126: (1, {'@': 734}), 231: (1, {'@': 734}), 234: (1, {'@': 734}), 57: (1, {'@': 734}), 241: (1, {'@': 734}), 243: (1, {'@': 734})}, 836: {126: (1, {'@': 373}), 146: (1, {'@': 373}), 60: (1, {'@': 373})}, 837: {133: (1, {'@': 683}), 130: (1, {'@': 683}), 141: (1, {'@': 683}), 60: (1, {'@': 683}), 129: (1, {'@': 683}), 126: (1, {'@': 683}), 134: (1, {'@': 683}), 57: (1, {'@': 683}), 132: (1, {'@': 683}), 139: (1, {'@': 683})}, 838: {126: (1, {'@': 379}), 146: (1, {'@': 379}), 60: (1, {'@': 379})}, 839: {80: (0, 2414), 194: (0, 1316), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 840: {126: (1, {'@': 363}), 146: (1, {'@': 363}), 60: (1, {'@': 363})}, 841: {403: (0, 193), 314: (0, 331), 554: (0, 1287), 555: (0, 1160), 405: (0, 1818)}, 842: {126: (1, {'@': 380}), 146: (1, {'@': 380}), 60: (1, {'@': 380})}, 843: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 1318), 112: (0, 2376), 97: (0, 2370)}, 844: {126: (1, {'@': 396}), 146: (1, {'@': 396}), 60: (1, {'@': 396})}, 845: {133: (1, {'@': 689}), 130: (1, {'@': 689}), 141: (1, {'@': 689}), 60: (1, {'@': 689}), 129: (1, {'@': 689}), 126: (1, {'@': 689}), 134: (1, {'@': 689}), 57: (1, {'@': 689}), 132: (1, {'@': 689}), 139: (1, {'@': 689})}, 846: {126: (1, {'@': 394}), 146: (1, {'@': 394}), 60: (1, {'@': 394})}, 847: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 1321)}, 848: {126: (1, {'@': 398}), 146: (1, {'@': 398}), 60: (1, {'@': 398})}, 849: {133: (1, {'@': 704}), 130: (1, {'@': 704}), 141: (1, {'@': 704}), 60: (1, {'@': 704}), 129: (1, {'@': 704}), 126: (1, {'@': 704}), 134: (1, {'@': 704}), 57: (1, {'@': 704}), 132: (1, {'@': 704}), 139: (1, {'@': 704})}, 850: {126: (1, {'@': 400}), 146: (1, {'@': 400}), 60: (1, {'@': 400})}, 851: {133: (1, {'@': 695}), 130: (1, {'@': 695}), 141: (1, {'@': 695}), 60: (1, {'@': 695}), 129: (1, {'@': 695}), 126: (1, {'@': 695}), 134: (1, {'@': 695}), 57: (1, {'@': 695}), 132: (1, {'@': 695}), 139: (1, {'@': 695})}, 852: {80: (0, 2414), 81: (0, 2295), 194: (0, 1322), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 853: {126: (1, {'@': 378}), 146: (1, {'@': 378}), 60: (1, {'@': 378})}, 854: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 535), 112: (0, 2376), 97: (0, 2370)}, 855: {126: (1, {'@': 397}), 146: (1, {'@': 397}), 60: (1, {'@': 397})}, 856: {126: (1, {'@': 413}), 146: (1, {'@': 413}), 60: (1, {'@': 413})}, 857: {60: (1, {'@': 1081}), 125: (1, {'@': 1081}), 41: (1, {'@': 1081}), 127: (1, {'@': 1081}), 126: (1, {'@': 1081}), 53: (1, {'@': 1081}), 57: (1, {'@': 1081})}, 858: {126: (1, {'@': 386}), 146: (1, {'@': 386}), 60: (1, {'@': 386})}, 859: {80: (0, 2414), 194: (0, 1350), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 860: {126: (1, {'@': 391}), 146: (1, {'@': 391}), 60: (1, {'@': 391})}, 861: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 1326), 112: (0, 2376), 97: (0, 2370)}, 862: {126: (0, 1243), 60: (1, {'@': 1546})}, 863: {126: (1, {'@': 408}), 146: (1, {'@': 408}), 60: (1, {'@': 408})}, 864: {126: (1, {'@': 407}), 146: (1, {'@': 407}), 60: (1, {'@': 407})}, 865: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 1325), 112: (0, 2376), 97: (0, 2370)}, 866: {133: (1, {'@': 1651}), 130: (1, {'@': 1651}), 141: (1, {'@': 1651}), 60: (1, {'@': 1651}), 129: (1, {'@': 1651}), 126: (1, {'@': 1651}), 134: (1, {'@': 1651}), 57: (1, {'@': 1651}), 132: (1, {'@': 1651}), 139: (1, {'@': 1651})}, 867: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 428: (0, 2122), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 194: (0, 1223), 89: (0, 2384), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 86: (0, 2123), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 868: {556: (0, 1312), 557: (0, 1203), 558: (0, 1200), 559: (0, 1197)}, 869: {112: (0, 2227)}, 870: {60: (1, {'@': 653}), 126: (1, {'@': 653}), 222: (1, {'@': 653}), 220: (1, {'@': 653}), 36: (1, {'@': 653}), 221: (1, {'@': 653}), 223: (1, {'@': 653}), 57: (1, {'@': 653})}, 871: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 1338), 112: (0, 2376), 97: (0, 2370)}, 872: {112: (0, 2549)}, 873: {144: (0, 1324), 560: (0, 1327)}, 874: {112: (0, 1899), 60: (1, {'@': 667}), 126: (1, {'@': 667}), 222: (1, {'@': 667}), 220: (1, {'@': 667}), 36: (1, {'@': 667}), 221: (1, {'@': 667}), 223: (1, {'@': 667}), 57: (1, {'@': 667})}, 875: {59: (1, {'@': 1412}), 60: (1, {'@': 1412}), 21: (1, {'@': 1412}), 22: (1, {'@': 1412}), 44: (1, {'@': 1412}), 126: (1, {'@': 1412}), 62: (1, {'@': 1412}), 61: (1, {'@': 1412}), 23: (1, {'@': 1412}), 25: (1, {'@': 1412}), 28: (1, {'@': 1412}), 49: (1, {'@': 1412}), 6: (1, {'@': 1412}), 33: (1, {'@': 1412}), 7: (1, {'@': 1412}), 53: (1, {'@': 1412}), 69: (1, {'@': 1412}), 40: (1, {'@': 1412}), 41: (1, {'@': 1412}), 75: (1, {'@': 1412}), 73: (1, {'@': 1412}), 57: (1, {'@': 1412}), 43: (1, {'@': 1412}), 45: (1, {'@': 1412}), 27: (1, {'@': 1412}), 64: (1, {'@': 1412}), 34: (1, {'@': 1412}), 37: (1, {'@': 1412}), 54: (1, {'@': 1412}), 38: (1, {'@': 1412}), 74: (1, {'@': 1412}), 18: (1, {'@': 1412}), 58: (1, {'@': 1412}), 66: (1, {'@': 1412}), 2: (1, {'@': 1412}), 63: (1, {'@': 1412}), 52: (1, {'@': 1412}), 8: (1, {'@': 1412}), 71: (1, {'@': 1412}), 55: (1, {'@': 1412}), 1: (1, {'@': 1412}), 47: (1, {'@': 1412}), 48: (1, {'@': 1412}), 4: (1, {'@': 1412}), 50: (1, {'@': 1412}), 51: (1, {'@': 1412}), 9: (1, {'@': 1412}), 11: (1, {'@': 1412}), 15: (1, {'@': 1412}), 17: (1, {'@': 1412}), 26: (1, {'@': 1412}), 29: (1, {'@': 1412}), 30: (1, {'@': 1412}), 31: (1, {'@': 1412}), 67: (1, {'@': 1412}), 36: (1, {'@': 1412}), 68: (1, {'@': 1412}), 70: (1, {'@': 1412}), 72: (1, {'@': 1412})}, 876: {112: (0, 2233)}, 877: {59: (1, {'@': 1385}), 60: (1, {'@': 1385}), 21: (1, {'@': 1385}), 22: (1, {'@': 1385}), 44: (1, {'@': 1385}), 126: (1, {'@': 1385}), 62: (1, {'@': 1385}), 61: (1, {'@': 1385}), 23: (1, {'@': 1385}), 25: (1, {'@': 1385}), 28: (1, {'@': 1385}), 49: (1, {'@': 1385}), 6: (1, {'@': 1385}), 33: (1, {'@': 1385}), 7: (1, {'@': 1385}), 53: (1, {'@': 1385}), 69: (1, {'@': 1385}), 40: (1, {'@': 1385}), 41: (1, {'@': 1385}), 75: (1, {'@': 1385}), 73: (1, {'@': 1385}), 57: (1, {'@': 1385}), 174: (1, {'@': 1385}), 175: (1, {'@': 1385}), 176: (1, {'@': 1385}), 177: (1, {'@': 1385}), 48: (1, {'@': 1385}), 72: (1, {'@': 1385}), 178: (1, {'@': 1385}), 179: (1, {'@': 1385}), 64: (1, {'@': 1385}), 34: (1, {'@': 1385}), 54: (1, {'@': 1385}), 18: (1, {'@': 1385}), 43: (1, {'@': 1385}), 1: (1, {'@': 1385}), 2: (1, {'@': 1385}), 45: (1, {'@': 1385}), 47: (1, {'@': 1385}), 4: (1, {'@': 1385}), 50: (1, {'@': 1385}), 51: (1, {'@': 1385}), 52: (1, {'@': 1385}), 8: (1, {'@': 1385}), 9: (1, {'@': 1385}), 11: (1, {'@': 1385}), 55: (1, {'@': 1385}), 15: (1, {'@': 1385}), 17: (1, {'@': 1385}), 58: (1, {'@': 1385}), 26: (1, {'@': 1385}), 63: (1, {'@': 1385}), 27: (1, {'@': 1385}), 29: (1, {'@': 1385}), 30: (1, {'@': 1385}), 31: (1, {'@': 1385}), 66: (1, {'@': 1385}), 67: (1, {'@': 1385}), 36: (1, {'@': 1385}), 37: (1, {'@': 1385}), 68: (1, {'@': 1385}), 38: (1, {'@': 1385}), 70: (1, {'@': 1385}), 71: (1, {'@': 1385}), 74: (1, {'@': 1385})}, 878: {60: (1, {'@': 650}), 57: (1, {'@': 650})}, 879: {126: (0, 2255), 220: (0, 869), 197: (0, 870), 221: (0, 872), 36: (0, 15), 222: (0, 874), 223: (0, 876), 226: (0, 883), 225: (0, 2262), 561: (0, 2264), 227: (0, 885), 228: (0, 887), 229: (0, 889), 57: (1, {'@': 652}), 60: (1, {'@': 652})}, 880: {144: (0, 2316), 145: (0, 1371)}, 881: {60: (0, 2073)}, 882: {57: (1, {'@': 1425}), 60: (1, {'@': 1425}), 59: (1, {'@': 1425}), 21: (1, {'@': 1425}), 22: (1, {'@': 1425}), 44: (1, {'@': 1425}), 126: (1, {'@': 1425}), 62: (1, {'@': 1425}), 61: (1, {'@': 1425}), 23: (1, {'@': 1425}), 25: (1, {'@': 1425}), 28: (1, {'@': 1425}), 49: (1, {'@': 1425}), 6: (1, {'@': 1425}), 33: (1, {'@': 1425}), 7: (1, {'@': 1425}), 53: (1, {'@': 1425}), 69: (1, {'@': 1425}), 40: (1, {'@': 1425}), 41: (1, {'@': 1425}), 75: (1, {'@': 1425}), 73: (1, {'@': 1425}), 67: (1, {'@': 1425}), 37: (1, {'@': 1425}), 45: (1, {'@': 1425}), 38: (1, {'@': 1425}), 26: (1, {'@': 1425}), 27: (1, {'@': 1425}), 4: (1, {'@': 1425}), 29: (1, {'@': 1425}), 30: (1, {'@': 1425}), 15: (1, {'@': 1425}), 125: (1, {'@': 1425}), 127: (1, {'@': 1425}), 43: (1, {'@': 1425}), 64: (1, {'@': 1425}), 34: (1, {'@': 1425}), 54: (1, {'@': 1425}), 74: (1, {'@': 1425}), 18: (1, {'@': 1425}), 58: (1, {'@': 1425}), 66: (1, {'@': 1425}), 2: (1, {'@': 1425}), 63: (1, {'@': 1425}), 52: (1, {'@': 1425}), 8: (1, {'@': 1425}), 71: (1, {'@': 1425}), 55: (1, {'@': 1425}), 1: (1, {'@': 1425}), 47: (1, {'@': 1425}), 48: (1, {'@': 1425}), 50: (1, {'@': 1425}), 51: (1, {'@': 1425}), 9: (1, {'@': 1425}), 11: (1, {'@': 1425}), 17: (1, {'@': 1425}), 31: (1, {'@': 1425}), 36: (1, {'@': 1425}), 68: (1, {'@': 1425}), 70: (1, {'@': 1425}), 72: (1, {'@': 1425})}, 883: {60: (1, {'@': 657}), 126: (1, {'@': 657}), 222: (1, {'@': 657}), 220: (1, {'@': 657}), 36: (1, {'@': 657}), 221: (1, {'@': 657}), 223: (1, {'@': 657}), 57: (1, {'@': 657})}, 884: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 255: (0, 1221), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 439: (0, 1253), 46: (0, 781), 434: (0, 1214), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 436: (0, 1217), 96: (0, 789), 82: (0, 791), 98: (0, 793), 432: (0, 1242), 110: (0, 799), 19: (0, 800), 13: (0, 802), 562: (0, 1245), 563: (0, 1249), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 438: (0, 1230), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 256: (0, 1219), 0: (0, 846), 564: (0, 1335), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 86: (0, 1257), 42: (0, 858), 123: (0, 856), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 885: {60: (1, {'@': 655}), 126: (1, {'@': 655}), 222: (1, {'@': 655}), 220: (1, {'@': 655}), 36: (1, {'@': 655}), 221: (1, {'@': 655}), 223: (1, {'@': 655}), 57: (1, {'@': 655})}, 886: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 530: (0, 1344), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 86: (0, 1346), 116: (0, 780), 534: (0, 1352), 46: (0, 781), 56: (0, 783), 531: (0, 1354), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 532: (0, 1356), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 565: (0, 1368), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 533: (0, 1360), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864), 535: (0, 1362)}, 887: {60: (1, {'@': 654}), 126: (1, {'@': 654}), 222: (1, {'@': 654}), 220: (1, {'@': 654}), 36: (1, {'@': 654}), 221: (1, {'@': 654}), 223: (1, {'@': 654}), 57: (1, {'@': 654})}, 888: {126: (0, 1340), 146: (1, {'@': 1386})}, 889: {60: (1, {'@': 656}), 126: (1, {'@': 656}), 222: (1, {'@': 656}), 220: (1, {'@': 656}), 36: (1, {'@': 656}), 221: (1, {'@': 656}), 223: (1, {'@': 656}), 57: (1, {'@': 656})}, 890: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 530: (0, 1344), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 86: (0, 1346), 116: (0, 780), 534: (0, 1352), 46: (0, 781), 56: (0, 783), 531: (0, 1354), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 532: (0, 1356), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 533: (0, 1360), 90: (0, 853), 3: (0, 855), 565: (0, 1366), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864), 535: (0, 1362)}, 891: {112: (0, 2246), 230: (1, {'@': 729}), 60: (1, {'@': 729}), 235: (1, {'@': 729}), 240: (1, {'@': 729}), 126: (1, {'@': 729}), 231: (1, {'@': 729}), 234: (1, {'@': 729}), 57: (1, {'@': 729}), 241: (1, {'@': 729}), 243: (1, {'@': 729})}, 892: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 530: (0, 1344), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 86: (0, 1346), 116: (0, 780), 534: (0, 1352), 46: (0, 781), 56: (0, 783), 531: (0, 1354), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 532: (0, 1356), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 565: (0, 1359), 0: (0, 846), 88: (0, 848), 122: (0, 850), 533: (0, 1360), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864), 535: (0, 1362)}, 893: {112: (0, 111), 230: (1, {'@': 726}), 60: (1, {'@': 726}), 235: (1, {'@': 726}), 240: (1, {'@': 726}), 126: (1, {'@': 726}), 231: (1, {'@': 726}), 234: (1, {'@': 726}), 57: (1, {'@': 726}), 241: (1, {'@': 726}), 243: (1, {'@': 726})}, 894: {59: (1, {'@': 1458}), 60: (1, {'@': 1458}), 21: (1, {'@': 1458}), 22: (1, {'@': 1458}), 44: (1, {'@': 1458}), 126: (1, {'@': 1458}), 62: (1, {'@': 1458}), 61: (1, {'@': 1458}), 23: (1, {'@': 1458}), 25: (1, {'@': 1458}), 28: (1, {'@': 1458}), 49: (1, {'@': 1458}), 6: (1, {'@': 1458}), 33: (1, {'@': 1458}), 7: (1, {'@': 1458}), 53: (1, {'@': 1458}), 69: (1, {'@': 1458}), 40: (1, {'@': 1458}), 41: (1, {'@': 1458}), 75: (1, {'@': 1458}), 73: (1, {'@': 1458}), 57: (1, {'@': 1458}), 43: (1, {'@': 1458}), 45: (1, {'@': 1458}), 27: (1, {'@': 1458}), 64: (1, {'@': 1458}), 34: (1, {'@': 1458}), 37: (1, {'@': 1458}), 54: (1, {'@': 1458}), 38: (1, {'@': 1458}), 74: (1, {'@': 1458}), 18: (1, {'@': 1458}), 58: (1, {'@': 1458}), 66: (1, {'@': 1458}), 2: (1, {'@': 1458}), 63: (1, {'@': 1458}), 52: (1, {'@': 1458}), 8: (1, {'@': 1458}), 71: (1, {'@': 1458}), 55: (1, {'@': 1458}), 1: (1, {'@': 1458}), 47: (1, {'@': 1458}), 48: (1, {'@': 1458}), 4: (1, {'@': 1458}), 50: (1, {'@': 1458}), 51: (1, {'@': 1458}), 9: (1, {'@': 1458}), 11: (1, {'@': 1458}), 15: (1, {'@': 1458}), 17: (1, {'@': 1458}), 26: (1, {'@': 1458}), 29: (1, {'@': 1458}), 30: (1, {'@': 1458}), 31: (1, {'@': 1458}), 67: (1, {'@': 1458}), 36: (1, {'@': 1458}), 68: (1, {'@': 1458}), 70: (1, {'@': 1458}), 72: (1, {'@': 1458})}, 895: {126: (0, 2279), 230: (0, 891), 566: (0, 2287), 231: (0, 893), 234: (0, 900), 235: (0, 901), 236: (0, 903), 237: (0, 905), 239: (0, 910), 238: (0, 907), 240: (0, 912), 232: (0, 2289), 241: (0, 914), 242: (0, 916), 243: (0, 917), 244: (0, 919), 245: (0, 921), 57: (1, {'@': 708}), 60: (1, {'@': 708})}, 896: {59: (1, {'@': 1410}), 60: (1, {'@': 1410}), 21: (1, {'@': 1410}), 22: (1, {'@': 1410}), 44: (1, {'@': 1410}), 126: (1, {'@': 1410}), 62: (1, {'@': 1410}), 61: (1, {'@': 1410}), 23: (1, {'@': 1410}), 25: (1, {'@': 1410}), 28: (1, {'@': 1410}), 49: (1, {'@': 1410}), 6: (1, {'@': 1410}), 33: (1, {'@': 1410}), 7: (1, {'@': 1410}), 53: (1, {'@': 1410}), 69: (1, {'@': 1410}), 40: (1, {'@': 1410}), 41: (1, {'@': 1410}), 75: (1, {'@': 1410}), 73: (1, {'@': 1410}), 57: (1, {'@': 1410}), 43: (1, {'@': 1410}), 45: (1, {'@': 1410}), 27: (1, {'@': 1410}), 64: (1, {'@': 1410}), 34: (1, {'@': 1410}), 37: (1, {'@': 1410}), 54: (1, {'@': 1410}), 38: (1, {'@': 1410}), 74: (1, {'@': 1410}), 18: (1, {'@': 1410}), 58: (1, {'@': 1410}), 66: (1, {'@': 1410}), 2: (1, {'@': 1410}), 63: (1, {'@': 1410}), 52: (1, {'@': 1410}), 8: (1, {'@': 1410}), 71: (1, {'@': 1410}), 55: (1, {'@': 1410}), 1: (1, {'@': 1410}), 47: (1, {'@': 1410}), 48: (1, {'@': 1410}), 4: (1, {'@': 1410}), 50: (1, {'@': 1410}), 51: (1, {'@': 1410}), 9: (1, {'@': 1410}), 11: (1, {'@': 1410}), 15: (1, {'@': 1410}), 17: (1, {'@': 1410}), 26: (1, {'@': 1410}), 29: (1, {'@': 1410}), 30: (1, {'@': 1410}), 31: (1, {'@': 1410}), 67: (1, {'@': 1410}), 36: (1, {'@': 1410}), 68: (1, {'@': 1410}), 70: (1, {'@': 1410}), 72: (1, {'@': 1410})}, 897: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 530: (0, 1344), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 86: (0, 1346), 116: (0, 780), 534: (0, 1352), 46: (0, 781), 56: (0, 783), 531: (0, 1354), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 532: (0, 1356), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 565: (0, 1364), 88: (0, 848), 122: (0, 850), 533: (0, 1360), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864), 535: (0, 1362)}, 898: {60: (1, {'@': 706}), 57: (1, {'@': 706})}, 899: {59: (1, {'@': 1511}), 60: (1, {'@': 1511}), 21: (1, {'@': 1511}), 22: (1, {'@': 1511}), 44: (1, {'@': 1511}), 126: (1, {'@': 1511}), 62: (1, {'@': 1511}), 61: (1, {'@': 1511}), 23: (1, {'@': 1511}), 25: (1, {'@': 1511}), 28: (1, {'@': 1511}), 49: (1, {'@': 1511}), 6: (1, {'@': 1511}), 33: (1, {'@': 1511}), 7: (1, {'@': 1511}), 53: (1, {'@': 1511}), 69: (1, {'@': 1511}), 40: (1, {'@': 1511}), 41: (1, {'@': 1511}), 75: (1, {'@': 1511}), 73: (1, {'@': 1511}), 57: (1, {'@': 1511}), 125: (1, {'@': 1511}), 127: (1, {'@': 1511}), 43: (1, {'@': 1511}), 45: (1, {'@': 1511}), 27: (1, {'@': 1511}), 64: (1, {'@': 1511}), 34: (1, {'@': 1511}), 37: (1, {'@': 1511}), 54: (1, {'@': 1511}), 38: (1, {'@': 1511}), 74: (1, {'@': 1511}), 18: (1, {'@': 1511}), 1: (1, {'@': 1511}), 2: (1, {'@': 1511}), 47: (1, {'@': 1511}), 48: (1, {'@': 1511}), 4: (1, {'@': 1511}), 50: (1, {'@': 1511}), 51: (1, {'@': 1511}), 52: (1, {'@': 1511}), 8: (1, {'@': 1511}), 9: (1, {'@': 1511}), 11: (1, {'@': 1511}), 55: (1, {'@': 1511}), 15: (1, {'@': 1511}), 17: (1, {'@': 1511}), 58: (1, {'@': 1511}), 26: (1, {'@': 1511}), 63: (1, {'@': 1511}), 29: (1, {'@': 1511}), 30: (1, {'@': 1511}), 31: (1, {'@': 1511}), 66: (1, {'@': 1511}), 67: (1, {'@': 1511}), 36: (1, {'@': 1511}), 68: (1, {'@': 1511}), 70: (1, {'@': 1511}), 71: (1, {'@': 1511}), 72: (1, {'@': 1511})}, 900: {112: (0, 114)}, 901: {112: (0, 926), 230: (1, {'@': 735}), 60: (1, {'@': 735}), 235: (1, {'@': 735}), 240: (1, {'@': 735}), 126: (1, {'@': 735}), 231: (1, {'@': 735}), 234: (1, {'@': 735}), 57: (1, {'@': 735}), 241: (1, {'@': 735}), 243: (1, {'@': 735})}, 902: {59: (1, {'@': 1489}), 60: (1, {'@': 1489}), 21: (1, {'@': 1489}), 22: (1, {'@': 1489}), 44: (1, {'@': 1489}), 126: (1, {'@': 1489}), 62: (1, {'@': 1489}), 61: (1, {'@': 1489}), 23: (1, {'@': 1489}), 25: (1, {'@': 1489}), 28: (1, {'@': 1489}), 49: (1, {'@': 1489}), 6: (1, {'@': 1489}), 33: (1, {'@': 1489}), 7: (1, {'@': 1489}), 53: (1, {'@': 1489}), 69: (1, {'@': 1489}), 40: (1, {'@': 1489}), 41: (1, {'@': 1489}), 75: (1, {'@': 1489}), 73: (1, {'@': 1489}), 57: (1, {'@': 1489}), 64: (1, {'@': 1489}), 34: (1, {'@': 1489}), 54: (1, {'@': 1489}), 18: (1, {'@': 1489}), 43: (1, {'@': 1489}), 1: (1, {'@': 1489}), 2: (1, {'@': 1489}), 45: (1, {'@': 1489}), 47: (1, {'@': 1489}), 48: (1, {'@': 1489}), 4: (1, {'@': 1489}), 50: (1, {'@': 1489}), 51: (1, {'@': 1489}), 52: (1, {'@': 1489}), 8: (1, {'@': 1489}), 9: (1, {'@': 1489}), 11: (1, {'@': 1489}), 55: (1, {'@': 1489}), 15: (1, {'@': 1489}), 17: (1, {'@': 1489}), 58: (1, {'@': 1489}), 26: (1, {'@': 1489}), 63: (1, {'@': 1489}), 27: (1, {'@': 1489}), 29: (1, {'@': 1489}), 30: (1, {'@': 1489}), 31: (1, {'@': 1489}), 66: (1, {'@': 1489}), 67: (1, {'@': 1489}), 36: (1, {'@': 1489}), 37: (1, {'@': 1489}), 68: (1, {'@': 1489}), 38: (1, {'@': 1489}), 70: (1, {'@': 1489}), 71: (1, {'@': 1489}), 72: (1, {'@': 1489}), 74: (1, {'@': 1489})}, 903: {230: (1, {'@': 709}), 60: (1, {'@': 709}), 235: (1, {'@': 709}), 240: (1, {'@': 709}), 126: (1, {'@': 709}), 231: (1, {'@': 709}), 234: (1, {'@': 709}), 57: (1, {'@': 709}), 241: (1, {'@': 709}), 243: (1, {'@': 709})}, 904: {59: (1, {'@': 1406}), 60: (1, {'@': 1406}), 21: (1, {'@': 1406}), 22: (1, {'@': 1406}), 44: (1, {'@': 1406}), 126: (1, {'@': 1406}), 62: (1, {'@': 1406}), 61: (1, {'@': 1406}), 23: (1, {'@': 1406}), 25: (1, {'@': 1406}), 28: (1, {'@': 1406}), 49: (1, {'@': 1406}), 6: (1, {'@': 1406}), 33: (1, {'@': 1406}), 7: (1, {'@': 1406}), 53: (1, {'@': 1406}), 69: (1, {'@': 1406}), 40: (1, {'@': 1406}), 41: (1, {'@': 1406}), 75: (1, {'@': 1406}), 73: (1, {'@': 1406}), 57: (1, {'@': 1406}), 43: (1, {'@': 1406}), 45: (1, {'@': 1406}), 27: (1, {'@': 1406}), 64: (1, {'@': 1406}), 34: (1, {'@': 1406}), 37: (1, {'@': 1406}), 54: (1, {'@': 1406}), 38: (1, {'@': 1406}), 74: (1, {'@': 1406}), 18: (1, {'@': 1406}), 58: (1, {'@': 1406}), 66: (1, {'@': 1406}), 2: (1, {'@': 1406}), 63: (1, {'@': 1406}), 52: (1, {'@': 1406}), 8: (1, {'@': 1406}), 71: (1, {'@': 1406}), 55: (1, {'@': 1406}), 1: (1, {'@': 1406}), 47: (1, {'@': 1406}), 48: (1, {'@': 1406}), 4: (1, {'@': 1406}), 50: (1, {'@': 1406}), 51: (1, {'@': 1406}), 9: (1, {'@': 1406}), 11: (1, {'@': 1406}), 15: (1, {'@': 1406}), 17: (1, {'@': 1406}), 26: (1, {'@': 1406}), 29: (1, {'@': 1406}), 30: (1, {'@': 1406}), 31: (1, {'@': 1406}), 67: (1, {'@': 1406}), 36: (1, {'@': 1406}), 68: (1, {'@': 1406}), 70: (1, {'@': 1406}), 72: (1, {'@': 1406})}, 905: {230: (1, {'@': 712}), 60: (1, {'@': 712}), 235: (1, {'@': 712}), 240: (1, {'@': 712}), 126: (1, {'@': 712}), 231: (1, {'@': 712}), 234: (1, {'@': 712}), 57: (1, {'@': 712}), 241: (1, {'@': 712}), 243: (1, {'@': 712})}, 906: {567: (0, 1424), 568: (0, 1430), 569: (0, 1395)}, 907: {230: (1, {'@': 713}), 60: (1, {'@': 713}), 235: (1, {'@': 713}), 240: (1, {'@': 713}), 126: (1, {'@': 713}), 231: (1, {'@': 713}), 234: (1, {'@': 713}), 57: (1, {'@': 713}), 241: (1, {'@': 713}), 243: (1, {'@': 713})}, 908: {59: (1, {'@': 1408}), 60: (1, {'@': 1408}), 21: (1, {'@': 1408}), 22: (1, {'@': 1408}), 44: (1, {'@': 1408}), 126: (1, {'@': 1408}), 62: (1, {'@': 1408}), 61: (1, {'@': 1408}), 23: (1, {'@': 1408}), 25: (1, {'@': 1408}), 28: (1, {'@': 1408}), 49: (1, {'@': 1408}), 6: (1, {'@': 1408}), 33: (1, {'@': 1408}), 7: (1, {'@': 1408}), 53: (1, {'@': 1408}), 69: (1, {'@': 1408}), 40: (1, {'@': 1408}), 41: (1, {'@': 1408}), 75: (1, {'@': 1408}), 73: (1, {'@': 1408}), 57: (1, {'@': 1408}), 43: (1, {'@': 1408}), 45: (1, {'@': 1408}), 27: (1, {'@': 1408}), 64: (1, {'@': 1408}), 34: (1, {'@': 1408}), 37: (1, {'@': 1408}), 54: (1, {'@': 1408}), 38: (1, {'@': 1408}), 74: (1, {'@': 1408}), 18: (1, {'@': 1408}), 58: (1, {'@': 1408}), 66: (1, {'@': 1408}), 2: (1, {'@': 1408}), 63: (1, {'@': 1408}), 52: (1, {'@': 1408}), 8: (1, {'@': 1408}), 71: (1, {'@': 1408}), 55: (1, {'@': 1408}), 1: (1, {'@': 1408}), 47: (1, {'@': 1408}), 48: (1, {'@': 1408}), 4: (1, {'@': 1408}), 50: (1, {'@': 1408}), 51: (1, {'@': 1408}), 9: (1, {'@': 1408}), 11: (1, {'@': 1408}), 15: (1, {'@': 1408}), 17: (1, {'@': 1408}), 26: (1, {'@': 1408}), 29: (1, {'@': 1408}), 30: (1, {'@': 1408}), 31: (1, {'@': 1408}), 67: (1, {'@': 1408}), 36: (1, {'@': 1408}), 68: (1, {'@': 1408}), 70: (1, {'@': 1408}), 72: (1, {'@': 1408})}, 909: {144: (0, 2316), 145: (0, 1348)}, 910: {230: (1, {'@': 711}), 60: (1, {'@': 711}), 235: (1, {'@': 711}), 240: (1, {'@': 711}), 126: (1, {'@': 711}), 231: (1, {'@': 711}), 234: (1, {'@': 711}), 57: (1, {'@': 711}), 241: (1, {'@': 711}), 243: (1, {'@': 711})}, 911: {59: (1, {'@': 1515}), 60: (1, {'@': 1515}), 21: (1, {'@': 1515}), 22: (1, {'@': 1515}), 44: (1, {'@': 1515}), 126: (1, {'@': 1515}), 62: (1, {'@': 1515}), 61: (1, {'@': 1515}), 23: (1, {'@': 1515}), 25: (1, {'@': 1515}), 28: (1, {'@': 1515}), 49: (1, {'@': 1515}), 6: (1, {'@': 1515}), 33: (1, {'@': 1515}), 7: (1, {'@': 1515}), 53: (1, {'@': 1515}), 69: (1, {'@': 1515}), 40: (1, {'@': 1515}), 41: (1, {'@': 1515}), 75: (1, {'@': 1515}), 73: (1, {'@': 1515}), 57: (1, {'@': 1515}), 43: (1, {'@': 1515}), 1: (1, {'@': 1515}), 2: (1, {'@': 1515}), 45: (1, {'@': 1515}), 47: (1, {'@': 1515}), 48: (1, {'@': 1515}), 4: (1, {'@': 1515}), 50: (1, {'@': 1515}), 51: (1, {'@': 1515}), 52: (1, {'@': 1515}), 8: (1, {'@': 1515}), 9: (1, {'@': 1515}), 11: (1, {'@': 1515}), 54: (1, {'@': 1515}), 55: (1, {'@': 1515}), 15: (1, {'@': 1515}), 17: (1, {'@': 1515}), 18: (1, {'@': 1515}), 58: (1, {'@': 1515}), 26: (1, {'@': 1515}), 63: (1, {'@': 1515}), 27: (1, {'@': 1515}), 29: (1, {'@': 1515}), 30: (1, {'@': 1515}), 31: (1, {'@': 1515}), 64: (1, {'@': 1515}), 66: (1, {'@': 1515}), 67: (1, {'@': 1515}), 34: (1, {'@': 1515}), 36: (1, {'@': 1515}), 37: (1, {'@': 1515}), 68: (1, {'@': 1515}), 38: (1, {'@': 1515}), 70: (1, {'@': 1515}), 71: (1, {'@': 1515}), 72: (1, {'@': 1515}), 74: (1, {'@': 1515})}, 912: {112: (0, 1458), 230: (1, {'@': 732}), 60: (1, {'@': 732}), 235: (1, {'@': 732}), 240: (1, {'@': 732}), 126: (1, {'@': 732}), 231: (1, {'@': 732}), 234: (1, {'@': 732}), 57: (1, {'@': 732}), 241: (1, {'@': 732}), 243: (1, {'@': 732})}, 913: {80: (0, 2414), 81: (0, 2295), 194: (0, 1374), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 914: {112: (0, 2252)}, 915: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 1381), 112: (0, 2376), 97: (0, 2370)}, 916: {230: (1, {'@': 710}), 60: (1, {'@': 710}), 235: (1, {'@': 710}), 240: (1, {'@': 710}), 126: (1, {'@': 710}), 231: (1, {'@': 710}), 234: (1, {'@': 710}), 57: (1, {'@': 710}), 241: (1, {'@': 710}), 243: (1, {'@': 710})}, 917: {112: (0, 2275)}, 918: {59: (1, {'@': 1508}), 60: (1, {'@': 1508}), 21: (1, {'@': 1508}), 22: (1, {'@': 1508}), 44: (1, {'@': 1508}), 126: (1, {'@': 1508}), 62: (1, {'@': 1508}), 61: (1, {'@': 1508}), 23: (1, {'@': 1508}), 25: (1, {'@': 1508}), 28: (1, {'@': 1508}), 49: (1, {'@': 1508}), 6: (1, {'@': 1508}), 33: (1, {'@': 1508}), 7: (1, {'@': 1508}), 53: (1, {'@': 1508}), 69: (1, {'@': 1508}), 40: (1, {'@': 1508}), 41: (1, {'@': 1508}), 75: (1, {'@': 1508}), 73: (1, {'@': 1508}), 57: (1, {'@': 1508}), 43: (1, {'@': 1508}), 45: (1, {'@': 1508}), 27: (1, {'@': 1508}), 64: (1, {'@': 1508}), 34: (1, {'@': 1508}), 37: (1, {'@': 1508}), 54: (1, {'@': 1508}), 38: (1, {'@': 1508}), 74: (1, {'@': 1508}), 18: (1, {'@': 1508}), 1: (1, {'@': 1508}), 2: (1, {'@': 1508}), 47: (1, {'@': 1508}), 48: (1, {'@': 1508}), 4: (1, {'@': 1508}), 50: (1, {'@': 1508}), 51: (1, {'@': 1508}), 52: (1, {'@': 1508}), 8: (1, {'@': 1508}), 9: (1, {'@': 1508}), 11: (1, {'@': 1508}), 55: (1, {'@': 1508}), 15: (1, {'@': 1508}), 17: (1, {'@': 1508}), 58: (1, {'@': 1508}), 26: (1, {'@': 1508}), 63: (1, {'@': 1508}), 29: (1, {'@': 1508}), 30: (1, {'@': 1508}), 31: (1, {'@': 1508}), 66: (1, {'@': 1508}), 67: (1, {'@': 1508}), 36: (1, {'@': 1508}), 68: (1, {'@': 1508}), 70: (1, {'@': 1508}), 71: (1, {'@': 1508}), 72: (1, {'@': 1508})}, 919: {230: (1, {'@': 715}), 60: (1, {'@': 715}), 235: (1, {'@': 715}), 240: (1, {'@': 715}), 126: (1, {'@': 715}), 231: (1, {'@': 715}), 234: (1, {'@': 715}), 57: (1, {'@': 715}), 241: (1, {'@': 715}), 243: (1, {'@': 715})}, 920: {86: (0, 2138), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 921: {230: (1, {'@': 714}), 60: (1, {'@': 714}), 235: (1, {'@': 714}), 240: (1, {'@': 714}), 126: (1, {'@': 714}), 231: (1, {'@': 714}), 234: (1, {'@': 714}), 57: (1, {'@': 714}), 241: (1, {'@': 714}), 243: (1, {'@': 714})}, 922: {144: (0, 2316), 145: (0, 1393)}, 923: {60: (1, {'@': 1079}), 125: (1, {'@': 1079}), 126: (1, {'@': 1079}), 53: (1, {'@': 1079}), 127: (1, {'@': 1079}), 41: (1, {'@': 1079}), 57: (1, {'@': 1079})}, 924: {454: (0, 188), 455: (0, 210), 456: (0, 212), 457: (0, 213), 458: (0, 215), 459: (0, 216), 460: (0, 1389), 461: (0, 219), 144: (0, 221), 462: (0, 223), 463: (0, 224)}, 925: {41: (0, 372), 246: (0, 2), 247: (0, 82), 201: (0, 923), 125: (0, 928), 53: (0, 387), 248: (0, 2230), 127: (0, 930), 126: (0, 2234), 172: (0, 933), 57: (1, {'@': 1075}), 60: (1, {'@': 1075})}, 926: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 86: (0, 2474), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 194: (0, 2476), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 927: {144: (0, 2143)}, 928: {112: (0, 2298)}, 929: {144: (0, 2316), 145: (0, 1385)}, 930: {112: (0, 375)}, 931: {126: (0, 1379)}, 932: {77: (0, 17), 78: (0, 1960), 79: (0, 1973), 12: (0, 396), 82: (0, 791), 83: (0, 809), 84: (0, 811), 85: (0, 816), 570: (0, 1330), 256: (0, 1332), 10: (0, 826), 87: (0, 842), 35: (0, 844), 571: (0, 1334), 88: (0, 848), 90: (0, 853), 91: (0, 863), 474: (0, 1337), 92: (0, 1944), 379: (0, 1341), 255: (0, 1221), 572: (0, 1345), 573: (0, 1349), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 56: (0, 783), 95: (0, 786), 574: (0, 1358), 96: (0, 789), 98: (0, 793), 19: (0, 800), 13: (0, 802), 32: (0, 807), 376: (0, 1361), 99: (0, 812), 100: (0, 817), 20: (0, 822), 102: (0, 823), 103: (0, 825), 575: (0, 1365), 576: (0, 1383), 105: (0, 830), 65: (0, 834), 577: (0, 1376), 106: (0, 838), 578: (0, 1382), 579: (0, 1386), 108: (0, 400), 109: (0, 390), 46: (0, 781), 580: (0, 1390), 110: (0, 799), 111: (0, 821), 14: (0, 399), 113: (0, 828), 114: (0, 832), 581: (0, 1398), 380: (0, 1402), 0: (0, 846), 42: (0, 858), 39: (0, 860), 115: (0, 44), 86: (0, 1408), 582: (0, 1412), 116: (0, 780), 5: (0, 787), 117: (0, 804), 24: (0, 814), 118: (0, 819), 119: (0, 836), 120: (0, 840), 122: (0, 850), 3: (0, 855), 123: (0, 856), 124: (0, 864)}, 933: {60: (1, {'@': 1078}), 125: (1, {'@': 1078}), 126: (1, {'@': 1078}), 53: (1, {'@': 1078}), 127: (1, {'@': 1078}), 41: (1, {'@': 1078}), 57: (1, {'@': 1078})}, 934: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 86: (0, 440), 116: (0, 780), 534: (0, 1352), 46: (0, 781), 56: (0, 783), 531: (0, 1354), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 583: (0, 758), 110: (0, 799), 19: (0, 800), 13: (0, 802), 530: (0, 600), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 532: (0, 1356), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 533: (0, 1360), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864), 535: (0, 1362)}, 935: {60: (1, {'@': 1071}), 57: (1, {'@': 1071})}, 936: {0: (1, {'@': 419}), 1: (1, {'@': 419}), 2: (1, {'@': 419}), 3: (1, {'@': 419}), 4: (1, {'@': 419}), 5: (1, {'@': 419}), 6: (1, {'@': 419}), 7: (1, {'@': 419}), 8: (1, {'@': 419}), 9: (1, {'@': 419}), 10: (1, {'@': 419}), 11: (1, {'@': 419}), 12: (1, {'@': 419}), 13: (1, {'@': 419}), 14: (1, {'@': 419}), 15: (1, {'@': 419}), 16: (1, {'@': 419}), 17: (1, {'@': 419}), 18: (1, {'@': 419}), 19: (1, {'@': 419}), 20: (1, {'@': 419}), 21: (1, {'@': 419}), 22: (1, {'@': 419}), 23: (1, {'@': 419}), 24: (1, {'@': 419}), 25: (1, {'@': 419}), 26: (1, {'@': 419}), 27: (1, {'@': 419}), 28: (1, {'@': 419}), 29: (1, {'@': 419}), 30: (1, {'@': 419}), 31: (1, {'@': 419}), 32: (1, {'@': 419}), 33: (1, {'@': 419}), 34: (1, {'@': 419}), 35: (1, {'@': 419}), 36: (1, {'@': 419}), 37: (1, {'@': 419}), 38: (1, {'@': 419}), 39: (1, {'@': 419}), 40: (1, {'@': 419}), 41: (1, {'@': 419}), 42: (1, {'@': 419}), 43: (1, {'@': 419}), 44: (1, {'@': 419}), 45: (1, {'@': 419}), 46: (1, {'@': 419}), 47: (1, {'@': 419}), 48: (1, {'@': 419}), 49: (1, {'@': 419}), 50: (1, {'@': 419}), 51: (1, {'@': 419}), 52: (1, {'@': 419}), 53: (1, {'@': 419}), 54: (1, {'@': 419}), 55: (1, {'@': 419}), 56: (1, {'@': 419}), 57: (1, {'@': 419}), 58: (1, {'@': 419}), 59: (1, {'@': 419}), 60: (1, {'@': 419}), 61: (1, {'@': 419}), 62: (1, {'@': 419}), 63: (1, {'@': 419}), 64: (1, {'@': 419}), 65: (1, {'@': 419}), 66: (1, {'@': 419}), 67: (1, {'@': 419}), 68: (1, {'@': 419}), 69: (1, {'@': 419}), 70: (1, {'@': 419}), 71: (1, {'@': 419}), 72: (1, {'@': 419}), 73: (1, {'@': 419}), 74: (1, {'@': 419}), 75: (1, {'@': 419})}, 937: {59: (1, {'@': 1398}), 60: (1, {'@': 1398}), 21: (1, {'@': 1398}), 22: (1, {'@': 1398}), 44: (1, {'@': 1398}), 126: (1, {'@': 1398}), 62: (1, {'@': 1398}), 61: (1, {'@': 1398}), 23: (1, {'@': 1398}), 25: (1, {'@': 1398}), 28: (1, {'@': 1398}), 49: (1, {'@': 1398}), 6: (1, {'@': 1398}), 33: (1, {'@': 1398}), 7: (1, {'@': 1398}), 53: (1, {'@': 1398}), 69: (1, {'@': 1398}), 40: (1, {'@': 1398}), 41: (1, {'@': 1398}), 75: (1, {'@': 1398}), 73: (1, {'@': 1398}), 57: (1, {'@': 1398}), 174: (1, {'@': 1398}), 175: (1, {'@': 1398}), 176: (1, {'@': 1398}), 177: (1, {'@': 1398}), 48: (1, {'@': 1398}), 72: (1, {'@': 1398}), 178: (1, {'@': 1398}), 179: (1, {'@': 1398}), 43: (1, {'@': 1398}), 1: (1, {'@': 1398}), 2: (1, {'@': 1398}), 45: (1, {'@': 1398}), 47: (1, {'@': 1398}), 4: (1, {'@': 1398}), 50: (1, {'@': 1398}), 51: (1, {'@': 1398}), 52: (1, {'@': 1398}), 8: (1, {'@': 1398}), 9: (1, {'@': 1398}), 11: (1, {'@': 1398}), 54: (1, {'@': 1398}), 55: (1, {'@': 1398}), 15: (1, {'@': 1398}), 17: (1, {'@': 1398}), 18: (1, {'@': 1398}), 58: (1, {'@': 1398}), 26: (1, {'@': 1398}), 63: (1, {'@': 1398}), 27: (1, {'@': 1398}), 29: (1, {'@': 1398}), 30: (1, {'@': 1398}), 31: (1, {'@': 1398}), 64: (1, {'@': 1398}), 66: (1, {'@': 1398}), 67: (1, {'@': 1398}), 34: (1, {'@': 1398}), 36: (1, {'@': 1398}), 37: (1, {'@': 1398}), 68: (1, {'@': 1398}), 38: (1, {'@': 1398}), 70: (1, {'@': 1398}), 71: (1, {'@': 1398}), 74: (1, {'@': 1398})}, 938: {60: (1, {'@': 1216}), 7: (1, {'@': 1216}), 22: (1, {'@': 1216}), 126: (1, {'@': 1216}), 174: (1, {'@': 1216}), 175: (1, {'@': 1216}), 49: (1, {'@': 1216}), 57: (1, {'@': 1216}), 176: (1, {'@': 1216})}, 939: {584: (0, 1378), 585: (0, 1387), 586: (0, 1369), 587: (0, 1415), 588: (0, 1353)}, 940: {112: (0, 1489)}, 941: {59: (1, {'@': 1110}), 60: (1, {'@': 1110}), 21: (1, {'@': 1110}), 22: (1, {'@': 1110}), 44: (1, {'@': 1110}), 126: (1, {'@': 1110}), 62: (1, {'@': 1110}), 61: (1, {'@': 1110}), 23: (1, {'@': 1110}), 25: (1, {'@': 1110}), 28: (1, {'@': 1110}), 49: (1, {'@': 1110}), 6: (1, {'@': 1110}), 33: (1, {'@': 1110}), 7: (1, {'@': 1110}), 53: (1, {'@': 1110}), 69: (1, {'@': 1110}), 40: (1, {'@': 1110}), 41: (1, {'@': 1110}), 75: (1, {'@': 1110}), 73: (1, {'@': 1110}), 57: (1, {'@': 1110}), 43: (1, {'@': 1110}), 1: (1, {'@': 1110}), 2: (1, {'@': 1110}), 45: (1, {'@': 1110}), 47: (1, {'@': 1110}), 48: (1, {'@': 1110}), 4: (1, {'@': 1110}), 50: (1, {'@': 1110}), 51: (1, {'@': 1110}), 52: (1, {'@': 1110}), 8: (1, {'@': 1110}), 9: (1, {'@': 1110}), 11: (1, {'@': 1110}), 54: (1, {'@': 1110}), 55: (1, {'@': 1110}), 15: (1, {'@': 1110}), 17: (1, {'@': 1110}), 18: (1, {'@': 1110}), 58: (1, {'@': 1110}), 26: (1, {'@': 1110}), 63: (1, {'@': 1110}), 27: (1, {'@': 1110}), 29: (1, {'@': 1110}), 30: (1, {'@': 1110}), 31: (1, {'@': 1110}), 64: (1, {'@': 1110}), 66: (1, {'@': 1110}), 67: (1, {'@': 1110}), 34: (1, {'@': 1110}), 36: (1, {'@': 1110}), 37: (1, {'@': 1110}), 68: (1, {'@': 1110}), 38: (1, {'@': 1110}), 70: (1, {'@': 1110}), 71: (1, {'@': 1110}), 72: (1, {'@': 1110}), 74: (1, {'@': 1110})}, 942: {250: (0, 938), 175: (0, 940), 22: (0, 389), 7: (0, 45), 49: (0, 335), 180: (0, 945), 206: (0, 947), 198: (0, 949), 174: (0, 953), 251: (0, 2319), 253: (0, 954), 176: (0, 951), 126: (0, 2321), 254: (0, 956), 57: (1, {'@': 1210}), 60: (1, {'@': 1210})}, 943: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 1404), 112: (0, 2376), 97: (0, 2370)}, 944: {60: (1, {'@': 1207}), 57: (1, {'@': 1207})}, 945: {60: (1, {'@': 1215}), 7: (1, {'@': 1215}), 22: (1, {'@': 1215}), 126: (1, {'@': 1215}), 174: (1, {'@': 1215}), 175: (1, {'@': 1215}), 49: (1, {'@': 1215}), 57: (1, {'@': 1215}), 176: (1, {'@': 1215})}, 946: {144: (0, 2316), 145: (0, 1400)}, 947: {60: (1, {'@': 1211}), 7: (1, {'@': 1211}), 22: (1, {'@': 1211}), 126: (1, {'@': 1211}), 174: (1, {'@': 1211}), 175: (1, {'@': 1211}), 49: (1, {'@': 1211}), 57: (1, {'@': 1211}), 176: (1, {'@': 1211})}, 948: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 86: (0, 1391), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 949: {60: (1, {'@': 1213}), 7: (1, {'@': 1213}), 22: (1, {'@': 1213}), 126: (1, {'@': 1213}), 174: (1, {'@': 1213}), 175: (1, {'@': 1213}), 49: (1, {'@': 1213}), 57: (1, {'@': 1213}), 176: (1, {'@': 1213})}, 950: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 1406), 112: (0, 2376), 97: (0, 2370)}, 951: {112: (0, 2312)}, 952: {59: (1, {'@': 1483}), 60: (1, {'@': 1483}), 21: (1, {'@': 1483}), 22: (1, {'@': 1483}), 44: (1, {'@': 1483}), 126: (1, {'@': 1483}), 62: (1, {'@': 1483}), 61: (1, {'@': 1483}), 23: (1, {'@': 1483}), 25: (1, {'@': 1483}), 28: (1, {'@': 1483}), 49: (1, {'@': 1483}), 6: (1, {'@': 1483}), 33: (1, {'@': 1483}), 7: (1, {'@': 1483}), 53: (1, {'@': 1483}), 69: (1, {'@': 1483}), 40: (1, {'@': 1483}), 41: (1, {'@': 1483}), 75: (1, {'@': 1483}), 73: (1, {'@': 1483}), 57: (1, {'@': 1483}), 43: (1, {'@': 1483}), 45: (1, {'@': 1483}), 27: (1, {'@': 1483}), 64: (1, {'@': 1483}), 34: (1, {'@': 1483}), 37: (1, {'@': 1483}), 54: (1, {'@': 1483}), 38: (1, {'@': 1483}), 74: (1, {'@': 1483}), 18: (1, {'@': 1483}), 1: (1, {'@': 1483}), 2: (1, {'@': 1483}), 47: (1, {'@': 1483}), 48: (1, {'@': 1483}), 4: (1, {'@': 1483}), 50: (1, {'@': 1483}), 51: (1, {'@': 1483}), 52: (1, {'@': 1483}), 8: (1, {'@': 1483}), 9: (1, {'@': 1483}), 11: (1, {'@': 1483}), 55: (1, {'@': 1483}), 15: (1, {'@': 1483}), 17: (1, {'@': 1483}), 58: (1, {'@': 1483}), 26: (1, {'@': 1483}), 63: (1, {'@': 1483}), 29: (1, {'@': 1483}), 30: (1, {'@': 1483}), 31: (1, {'@': 1483}), 66: (1, {'@': 1483}), 67: (1, {'@': 1483}), 36: (1, {'@': 1483}), 68: (1, {'@': 1483}), 70: (1, {'@': 1483}), 71: (1, {'@': 1483}), 72: (1, {'@': 1483})}, 953: {112: (0, 2271)}, 954: {60: (1, {'@': 1212}), 7: (1, {'@': 1212}), 22: (1, {'@': 1212}), 126: (1, {'@': 1212}), 174: (1, {'@': 1212}), 175: (1, {'@': 1212}), 49: (1, {'@': 1212}), 57: (1, {'@': 1212}), 176: (1, {'@': 1212})}, 955: {144: (0, 1403)}, 956: {60: (1, {'@': 1214}), 7: (1, {'@': 1214}), 22: (1, {'@': 1214}), 126: (1, {'@': 1214}), 174: (1, {'@': 1214}), 175: (1, {'@': 1214}), 49: (1, {'@': 1214}), 57: (1, {'@': 1214}), 176: (1, {'@': 1214})}, 957: {144: (0, 2316), 145: (0, 1399)}, 958: {59: (1, {'@': 1108}), 60: (1, {'@': 1108}), 21: (1, {'@': 1108}), 22: (1, {'@': 1108}), 44: (1, {'@': 1108}), 126: (1, {'@': 1108}), 62: (1, {'@': 1108}), 61: (1, {'@': 1108}), 23: (1, {'@': 1108}), 25: (1, {'@': 1108}), 28: (1, {'@': 1108}), 49: (1, {'@': 1108}), 6: (1, {'@': 1108}), 33: (1, {'@': 1108}), 7: (1, {'@': 1108}), 53: (1, {'@': 1108}), 69: (1, {'@': 1108}), 40: (1, {'@': 1108}), 41: (1, {'@': 1108}), 75: (1, {'@': 1108}), 73: (1, {'@': 1108}), 57: (1, {'@': 1108}), 43: (1, {'@': 1108}), 1: (1, {'@': 1108}), 2: (1, {'@': 1108}), 45: (1, {'@': 1108}), 47: (1, {'@': 1108}), 48: (1, {'@': 1108}), 4: (1, {'@': 1108}), 50: (1, {'@': 1108}), 51: (1, {'@': 1108}), 52: (1, {'@': 1108}), 8: (1, {'@': 1108}), 9: (1, {'@': 1108}), 11: (1, {'@': 1108}), 54: (1, {'@': 1108}), 55: (1, {'@': 1108}), 15: (1, {'@': 1108}), 17: (1, {'@': 1108}), 18: (1, {'@': 1108}), 58: (1, {'@': 1108}), 26: (1, {'@': 1108}), 63: (1, {'@': 1108}), 27: (1, {'@': 1108}), 29: (1, {'@': 1108}), 30: (1, {'@': 1108}), 31: (1, {'@': 1108}), 64: (1, {'@': 1108}), 66: (1, {'@': 1108}), 67: (1, {'@': 1108}), 34: (1, {'@': 1108}), 36: (1, {'@': 1108}), 37: (1, {'@': 1108}), 68: (1, {'@': 1108}), 38: (1, {'@': 1108}), 70: (1, {'@': 1108}), 71: (1, {'@': 1108}), 72: (1, {'@': 1108}), 74: (1, {'@': 1108})}, 959: {0: (1, {'@': 426}), 1: (1, {'@': 426}), 2: (1, {'@': 426}), 3: (1, {'@': 426}), 4: (1, {'@': 426}), 5: (1, {'@': 426}), 6: (1, {'@': 426}), 7: (1, {'@': 426}), 8: (1, {'@': 426}), 9: (1, {'@': 426}), 10: (1, {'@': 426}), 11: (1, {'@': 426}), 12: (1, {'@': 426}), 13: (1, {'@': 426}), 14: (1, {'@': 426}), 15: (1, {'@': 426}), 16: (1, {'@': 426}), 17: (1, {'@': 426}), 18: (1, {'@': 426}), 19: (1, {'@': 426}), 20: (1, {'@': 426}), 21: (1, {'@': 426}), 22: (1, {'@': 426}), 23: (1, {'@': 426}), 24: (1, {'@': 426}), 25: (1, {'@': 426}), 26: (1, {'@': 426}), 27: (1, {'@': 426}), 28: (1, {'@': 426}), 29: (1, {'@': 426}), 30: (1, {'@': 426}), 31: (1, {'@': 426}), 32: (1, {'@': 426}), 33: (1, {'@': 426}), 34: (1, {'@': 426}), 35: (1, {'@': 426}), 36: (1, {'@': 426}), 37: (1, {'@': 426}), 38: (1, {'@': 426}), 39: (1, {'@': 426}), 40: (1, {'@': 426}), 41: (1, {'@': 426}), 42: (1, {'@': 426}), 43: (1, {'@': 426}), 44: (1, {'@': 426}), 45: (1, {'@': 426}), 46: (1, {'@': 426}), 47: (1, {'@': 426}), 48: (1, {'@': 426}), 49: (1, {'@': 426}), 50: (1, {'@': 426}), 51: (1, {'@': 426}), 52: (1, {'@': 426}), 53: (1, {'@': 426}), 54: (1, {'@': 426}), 55: (1, {'@': 426}), 56: (1, {'@': 426}), 57: (1, {'@': 426}), 58: (1, {'@': 426}), 59: (1, {'@': 426}), 60: (1, {'@': 426}), 61: (1, {'@': 426}), 62: (1, {'@': 426}), 63: (1, {'@': 426}), 64: (1, {'@': 426}), 65: (1, {'@': 426}), 66: (1, {'@': 426}), 67: (1, {'@': 426}), 68: (1, {'@': 426}), 69: (1, {'@': 426}), 70: (1, {'@': 426}), 71: (1, {'@': 426}), 72: (1, {'@': 426}), 73: (1, {'@': 426}), 74: (1, {'@': 426}), 75: (1, {'@': 426})}, 960: {0: (1, {'@': 433}), 1: (1, {'@': 433}), 2: (1, {'@': 433}), 3: (1, {'@': 433}), 4: (1, {'@': 433}), 5: (1, {'@': 433}), 6: (1, {'@': 433}), 7: (1, {'@': 433}), 8: (1, {'@': 433}), 9: (1, {'@': 433}), 10: (1, {'@': 433}), 11: (1, {'@': 433}), 12: (1, {'@': 433}), 13: (1, {'@': 433}), 14: (1, {'@': 433}), 15: (1, {'@': 433}), 16: (1, {'@': 433}), 17: (1, {'@': 433}), 18: (1, {'@': 433}), 19: (1, {'@': 433}), 20: (1, {'@': 433}), 21: (1, {'@': 433}), 22: (1, {'@': 433}), 23: (1, {'@': 433}), 24: (1, {'@': 433}), 25: (1, {'@': 433}), 26: (1, {'@': 433}), 27: (1, {'@': 433}), 28: (1, {'@': 433}), 29: (1, {'@': 433}), 30: (1, {'@': 433}), 31: (1, {'@': 433}), 32: (1, {'@': 433}), 33: (1, {'@': 433}), 34: (1, {'@': 433}), 35: (1, {'@': 433}), 36: (1, {'@': 433}), 37: (1, {'@': 433}), 38: (1, {'@': 433}), 39: (1, {'@': 433}), 40: (1, {'@': 433}), 41: (1, {'@': 433}), 42: (1, {'@': 433}), 43: (1, {'@': 433}), 44: (1, {'@': 433}), 45: (1, {'@': 433}), 46: (1, {'@': 433}), 47: (1, {'@': 433}), 48: (1, {'@': 433}), 49: (1, {'@': 433}), 50: (1, {'@': 433}), 51: (1, {'@': 433}), 52: (1, {'@': 433}), 53: (1, {'@': 433}), 54: (1, {'@': 433}), 55: (1, {'@': 433}), 56: (1, {'@': 433}), 57: (1, {'@': 433}), 58: (1, {'@': 433}), 59: (1, {'@': 433}), 60: (1, {'@': 433}), 61: (1, {'@': 433}), 62: (1, {'@': 433}), 63: (1, {'@': 433}), 64: (1, {'@': 433}), 65: (1, {'@': 433}), 66: (1, {'@': 433}), 67: (1, {'@': 433}), 68: (1, {'@': 433}), 69: (1, {'@': 433}), 70: (1, {'@': 433}), 71: (1, {'@': 433}), 72: (1, {'@': 433}), 73: (1, {'@': 433}), 74: (1, {'@': 433}), 75: (1, {'@': 433})}, 961: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 86: (0, 2139), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 962: {0: (1, {'@': 435}), 1: (1, {'@': 435}), 2: (1, {'@': 435}), 3: (1, {'@': 435}), 4: (1, {'@': 435}), 5: (1, {'@': 435}), 6: (1, {'@': 435}), 7: (1, {'@': 435}), 8: (1, {'@': 435}), 9: (1, {'@': 435}), 10: (1, {'@': 435}), 11: (1, {'@': 435}), 12: (1, {'@': 435}), 13: (1, {'@': 435}), 14: (1, {'@': 435}), 15: (1, {'@': 435}), 16: (1, {'@': 435}), 17: (1, {'@': 435}), 18: (1, {'@': 435}), 19: (1, {'@': 435}), 20: (1, {'@': 435}), 21: (1, {'@': 435}), 22: (1, {'@': 435}), 23: (1, {'@': 435}), 24: (1, {'@': 435}), 25: (1, {'@': 435}), 26: (1, {'@': 435}), 27: (1, {'@': 435}), 28: (1, {'@': 435}), 29: (1, {'@': 435}), 30: (1, {'@': 435}), 31: (1, {'@': 435}), 32: (1, {'@': 435}), 33: (1, {'@': 435}), 34: (1, {'@': 435}), 35: (1, {'@': 435}), 36: (1, {'@': 435}), 37: (1, {'@': 435}), 38: (1, {'@': 435}), 39: (1, {'@': 435}), 40: (1, {'@': 435}), 41: (1, {'@': 435}), 42: (1, {'@': 435}), 43: (1, {'@': 435}), 44: (1, {'@': 435}), 45: (1, {'@': 435}), 46: (1, {'@': 435}), 47: (1, {'@': 435}), 48: (1, {'@': 435}), 49: (1, {'@': 435}), 50: (1, {'@': 435}), 51: (1, {'@': 435}), 52: (1, {'@': 435}), 53: (1, {'@': 435}), 54: (1, {'@': 435}), 55: (1, {'@': 435}), 56: (1, {'@': 435}), 57: (1, {'@': 435}), 58: (1, {'@': 435}), 59: (1, {'@': 435}), 60: (1, {'@': 435}), 61: (1, {'@': 435}), 62: (1, {'@': 435}), 63: (1, {'@': 435}), 64: (1, {'@': 435}), 65: (1, {'@': 435}), 66: (1, {'@': 435}), 67: (1, {'@': 435}), 68: (1, {'@': 435}), 69: (1, {'@': 435}), 70: (1, {'@': 435}), 71: (1, {'@': 435}), 72: (1, {'@': 435}), 73: (1, {'@': 435}), 74: (1, {'@': 435}), 75: (1, {'@': 435})}, 963: {59: (1, {'@': 1499}), 60: (1, {'@': 1499}), 21: (1, {'@': 1499}), 22: (1, {'@': 1499}), 44: (1, {'@': 1499}), 126: (1, {'@': 1499}), 62: (1, {'@': 1499}), 61: (1, {'@': 1499}), 23: (1, {'@': 1499}), 25: (1, {'@': 1499}), 28: (1, {'@': 1499}), 49: (1, {'@': 1499}), 6: (1, {'@': 1499}), 33: (1, {'@': 1499}), 7: (1, {'@': 1499}), 53: (1, {'@': 1499}), 69: (1, {'@': 1499}), 40: (1, {'@': 1499}), 41: (1, {'@': 1499}), 75: (1, {'@': 1499}), 73: (1, {'@': 1499}), 57: (1, {'@': 1499}), 43: (1, {'@': 1499}), 45: (1, {'@': 1499}), 27: (1, {'@': 1499}), 64: (1, {'@': 1499}), 34: (1, {'@': 1499}), 37: (1, {'@': 1499}), 54: (1, {'@': 1499}), 38: (1, {'@': 1499}), 74: (1, {'@': 1499}), 18: (1, {'@': 1499}), 1: (1, {'@': 1499}), 2: (1, {'@': 1499}), 47: (1, {'@': 1499}), 48: (1, {'@': 1499}), 4: (1, {'@': 1499}), 50: (1, {'@': 1499}), 51: (1, {'@': 1499}), 52: (1, {'@': 1499}), 8: (1, {'@': 1499}), 9: (1, {'@': 1499}), 11: (1, {'@': 1499}), 55: (1, {'@': 1499}), 15: (1, {'@': 1499}), 17: (1, {'@': 1499}), 58: (1, {'@': 1499}), 26: (1, {'@': 1499}), 63: (1, {'@': 1499}), 29: (1, {'@': 1499}), 30: (1, {'@': 1499}), 31: (1, {'@': 1499}), 66: (1, {'@': 1499}), 67: (1, {'@': 1499}), 36: (1, {'@': 1499}), 68: (1, {'@': 1499}), 70: (1, {'@': 1499}), 71: (1, {'@': 1499}), 72: (1, {'@': 1499})}, 964: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 194: (0, 1409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 965: {296: (0, 2462), 58: (0, 1666), 48: (0, 1843), 29: (0, 1870), 259: (0, 2464), 63: (0, 2218), 64: (0, 1537), 53: (0, 387), 41: (0, 372), 70: (0, 1727), 485: (0, 2465), 50: (0, 1792), 26: (0, 1797), 484: (0, 2472), 19: (0, 970), 8: (0, 1510), 38: (0, 1811), 183: (0, 2473), 49: (0, 335), 295: (0, 2475), 43: (0, 1548), 61: (0, 25), 16: (0, 972), 165: (0, 2477), 1: (0, 1793), 69: (0, 1760), 67: (0, 1913), 45: (0, 1833), 30: (0, 1920), 51: (0, 1695), 71: (0, 2263), 32: (0, 986), 206: (0, 2479), 52: (0, 1498), 6: (0, 20), 44: (0, 358), 203: (0, 2481), 280: (0, 2482), 40: (0, 1756), 15: (0, 1909), 33: (0, 383), 213: (0, 2484), 18: (0, 1581), 7: (0, 45), 445: (0, 2485), 0: (0, 102), 66: (0, 1679), 21: (0, 366), 56: (0, 959), 2: (0, 2225), 55: (0, 2229), 46: (0, 962), 217: (0, 2487), 166: (0, 2489), 59: (0, 363), 182: (0, 2490), 212: (0, 2492), 34: (0, 1589), 284: (0, 2496), 28: (0, 33), 36: (0, 15), 14: (0, 973), 54: (0, 1598), 164: (0, 2498), 20: (0, 975), 72: (0, 1882), 286: (0, 2500), 31: (0, 1901), 17: (0, 50), 10: (0, 983), 37: (0, 1828), 211: (0, 2501), 73: (0, 1763), 23: (0, 327), 22: (0, 389), 68: (0, 1724), 589: (0, 2503), 198: (0, 2505), 210: (0, 2507), 74: (0, 1616), 483: (0, 2508), 309: (0, 2510), 27: (0, 408), 392: (0, 2511), 180: (0, 2513), 292: (0, 2515), 398: (0, 2517), 287: (0, 2518), 4: (0, 405), 24: (0, 971), 200: (0, 2519), 11: (0, 84), 162: (0, 2522), 47: (0, 1820), 172: (0, 2524), 197: (0, 2526), 3: (0, 979), 410: (0, 2528), 202: (0, 2530), 9: (0, 1906), 39: (0, 989), 290: (0, 2532), 204: (0, 2534), 205: (0, 2537), 167: (0, 2539), 215: (0, 2541), 163: (0, 2543), 35: (0, 0), 207: (0, 2545), 62: (0, 367), 12: (0, 936), 185: (0, 2546), 5: (0, 960), 170: (0, 2550), 75: (0, 341), 168: (0, 2551), 395: (0, 2553), 396: (0, 2554), 444: (0, 2556), 161: (0, 2558), 208: (0, 2560), 481: (0, 2561), 173: (0, 2564), 13: (0, 981), 283: (0, 2567), 42: (0, 984), 169: (0, 2568), 25: (0, 1783), 479: (0, 2571), 482: (0, 2572), 201: (0, 2575), 281: (0, 2577), 65: (0, 991), 60: (1, {'@': 418}), 57: (1, {'@': 418})}, 966: {60: (1, {'@': 896}), 57: (1, {'@': 896})}, 967: {59: (1, {'@': 1495}), 60: (1, {'@': 1495}), 21: (1, {'@': 1495}), 22: (1, {'@': 1495}), 44: (1, {'@': 1495}), 126: (1, {'@': 1495}), 62: (1, {'@': 1495}), 61: (1, {'@': 1495}), 23: (1, {'@': 1495}), 25: (1, {'@': 1495}), 28: (1, {'@': 1495}), 49: (1, {'@': 1495}), 6: (1, {'@': 1495}), 33: (1, {'@': 1495}), 7: (1, {'@': 1495}), 53: (1, {'@': 1495}), 69: (1, {'@': 1495}), 40: (1, {'@': 1495}), 41: (1, {'@': 1495}), 75: (1, {'@': 1495}), 73: (1, {'@': 1495}), 57: (1, {'@': 1495}), 64: (1, {'@': 1495}), 34: (1, {'@': 1495}), 54: (1, {'@': 1495}), 18: (1, {'@': 1495}), 43: (1, {'@': 1495}), 1: (1, {'@': 1495}), 2: (1, {'@': 1495}), 45: (1, {'@': 1495}), 47: (1, {'@': 1495}), 48: (1, {'@': 1495}), 4: (1, {'@': 1495}), 50: (1, {'@': 1495}), 51: (1, {'@': 1495}), 52: (1, {'@': 1495}), 8: (1, {'@': 1495}), 9: (1, {'@': 1495}), 11: (1, {'@': 1495}), 55: (1, {'@': 1495}), 15: (1, {'@': 1495}), 17: (1, {'@': 1495}), 58: (1, {'@': 1495}), 26: (1, {'@': 1495}), 63: (1, {'@': 1495}), 27: (1, {'@': 1495}), 29: (1, {'@': 1495}), 30: (1, {'@': 1495}), 31: (1, {'@': 1495}), 66: (1, {'@': 1495}), 67: (1, {'@': 1495}), 36: (1, {'@': 1495}), 37: (1, {'@': 1495}), 68: (1, {'@': 1495}), 38: (1, {'@': 1495}), 70: (1, {'@': 1495}), 71: (1, {'@': 1495}), 72: (1, {'@': 1495}), 74: (1, {'@': 1495})}, 968: {144: (0, 2316), 145: (0, 1397)}, 969: {57: (1, {'@': 1159}), 60: (1, {'@': 1159}), 43: (1, {'@': 1159}), 1: (1, {'@': 1159}), 2: (1, {'@': 1159}), 44: (1, {'@': 1159}), 45: (1, {'@': 1159}), 47: (1, {'@': 1159}), 48: (1, {'@': 1159}), 4: (1, {'@': 1159}), 49: (1, {'@': 1159}), 50: (1, {'@': 1159}), 51: (1, {'@': 1159}), 6: (1, {'@': 1159}), 52: (1, {'@': 1159}), 8: (1, {'@': 1159}), 7: (1, {'@': 1159}), 9: (1, {'@': 1159}), 53: (1, {'@': 1159}), 11: (1, {'@': 1159}), 54: (1, {'@': 1159}), 55: (1, {'@': 1159}), 15: (1, {'@': 1159}), 17: (1, {'@': 1159}), 18: (1, {'@': 1159}), 58: (1, {'@': 1159}), 59: (1, {'@': 1159}), 21: (1, {'@': 1159}), 22: (1, {'@': 1159}), 61: (1, {'@': 1159}), 126: (1, {'@': 1159}), 62: (1, {'@': 1159}), 23: (1, {'@': 1159}), 25: (1, {'@': 1159}), 26: (1, {'@': 1159}), 63: (1, {'@': 1159}), 27: (1, {'@': 1159}), 28: (1, {'@': 1159}), 29: (1, {'@': 1159}), 30: (1, {'@': 1159}), 31: (1, {'@': 1159}), 33: (1, {'@': 1159}), 64: (1, {'@': 1159}), 66: (1, {'@': 1159}), 67: (1, {'@': 1159}), 34: (1, {'@': 1159}), 36: (1, {'@': 1159}), 37: (1, {'@': 1159}), 68: (1, {'@': 1159}), 38: (1, {'@': 1159}), 69: (1, {'@': 1159}), 70: (1, {'@': 1159}), 71: (1, {'@': 1159}), 40: (1, {'@': 1159}), 72: (1, {'@': 1159}), 41: (1, {'@': 1159}), 73: (1, {'@': 1159}), 74: (1, {'@': 1159}), 75: (1, {'@': 1159})}, 970: {0: (1, {'@': 432}), 1: (1, {'@': 432}), 2: (1, {'@': 432}), 3: (1, {'@': 432}), 4: (1, {'@': 432}), 5: (1, {'@': 432}), 6: (1, {'@': 432}), 7: (1, {'@': 432}), 8: (1, {'@': 432}), 9: (1, {'@': 432}), 10: (1, {'@': 432}), 11: (1, {'@': 432}), 12: (1, {'@': 432}), 13: (1, {'@': 432}), 14: (1, {'@': 432}), 15: (1, {'@': 432}), 16: (1, {'@': 432}), 17: (1, {'@': 432}), 18: (1, {'@': 432}), 19: (1, {'@': 432}), 20: (1, {'@': 432}), 21: (1, {'@': 432}), 22: (1, {'@': 432}), 23: (1, {'@': 432}), 24: (1, {'@': 432}), 25: (1, {'@': 432}), 26: (1, {'@': 432}), 27: (1, {'@': 432}), 28: (1, {'@': 432}), 29: (1, {'@': 432}), 30: (1, {'@': 432}), 31: (1, {'@': 432}), 32: (1, {'@': 432}), 33: (1, {'@': 432}), 34: (1, {'@': 432}), 35: (1, {'@': 432}), 36: (1, {'@': 432}), 37: (1, {'@': 432}), 38: (1, {'@': 432}), 39: (1, {'@': 432}), 40: (1, {'@': 432}), 41: (1, {'@': 432}), 42: (1, {'@': 432}), 43: (1, {'@': 432}), 44: (1, {'@': 432}), 45: (1, {'@': 432}), 46: (1, {'@': 432}), 47: (1, {'@': 432}), 48: (1, {'@': 432}), 49: (1, {'@': 432}), 50: (1, {'@': 432}), 51: (1, {'@': 432}), 52: (1, {'@': 432}), 53: (1, {'@': 432}), 54: (1, {'@': 432}), 55: (1, {'@': 432}), 56: (1, {'@': 432}), 57: (1, {'@': 432}), 58: (1, {'@': 432}), 59: (1, {'@': 432}), 60: (1, {'@': 432}), 61: (1, {'@': 432}), 62: (1, {'@': 432}), 63: (1, {'@': 432}), 64: (1, {'@': 432}), 65: (1, {'@': 432}), 66: (1, {'@': 432}), 67: (1, {'@': 432}), 68: (1, {'@': 432}), 69: (1, {'@': 432}), 70: (1, {'@': 432}), 71: (1, {'@': 432}), 72: (1, {'@': 432}), 73: (1, {'@': 432}), 74: (1, {'@': 432}), 75: (1, {'@': 432})}, 971: {0: (1, {'@': 434}), 1: (1, {'@': 434}), 2: (1, {'@': 434}), 3: (1, {'@': 434}), 4: (1, {'@': 434}), 5: (1, {'@': 434}), 6: (1, {'@': 434}), 7: (1, {'@': 434}), 8: (1, {'@': 434}), 9: (1, {'@': 434}), 10: (1, {'@': 434}), 11: (1, {'@': 434}), 12: (1, {'@': 434}), 13: (1, {'@': 434}), 14: (1, {'@': 434}), 15: (1, {'@': 434}), 16: (1, {'@': 434}), 17: (1, {'@': 434}), 18: (1, {'@': 434}), 19: (1, {'@': 434}), 20: (1, {'@': 434}), 21: (1, {'@': 434}), 22: (1, {'@': 434}), 23: (1, {'@': 434}), 24: (1, {'@': 434}), 25: (1, {'@': 434}), 26: (1, {'@': 434}), 27: (1, {'@': 434}), 28: (1, {'@': 434}), 29: (1, {'@': 434}), 30: (1, {'@': 434}), 31: (1, {'@': 434}), 32: (1, {'@': 434}), 33: (1, {'@': 434}), 34: (1, {'@': 434}), 35: (1, {'@': 434}), 36: (1, {'@': 434}), 37: (1, {'@': 434}), 38: (1, {'@': 434}), 39: (1, {'@': 434}), 40: (1, {'@': 434}), 41: (1, {'@': 434}), 42: (1, {'@': 434}), 43: (1, {'@': 434}), 44: (1, {'@': 434}), 45: (1, {'@': 434}), 46: (1, {'@': 434}), 47: (1, {'@': 434}), 48: (1, {'@': 434}), 49: (1, {'@': 434}), 50: (1, {'@': 434}), 51: (1, {'@': 434}), 52: (1, {'@': 434}), 53: (1, {'@': 434}), 54: (1, {'@': 434}), 55: (1, {'@': 434}), 56: (1, {'@': 434}), 57: (1, {'@': 434}), 58: (1, {'@': 434}), 59: (1, {'@': 434}), 60: (1, {'@': 434}), 61: (1, {'@': 434}), 62: (1, {'@': 434}), 63: (1, {'@': 434}), 64: (1, {'@': 434}), 65: (1, {'@': 434}), 66: (1, {'@': 434}), 67: (1, {'@': 434}), 68: (1, {'@': 434}), 69: (1, {'@': 434}), 70: (1, {'@': 434}), 71: (1, {'@': 434}), 72: (1, {'@': 434}), 73: (1, {'@': 434}), 74: (1, {'@': 434}), 75: (1, {'@': 434})}, 972: {0: (1, {'@': 427}), 1: (1, {'@': 427}), 2: (1, {'@': 427}), 3: (1, {'@': 427}), 4: (1, {'@': 427}), 5: (1, {'@': 427}), 6: (1, {'@': 427}), 7: (1, {'@': 427}), 8: (1, {'@': 427}), 9: (1, {'@': 427}), 10: (1, {'@': 427}), 11: (1, {'@': 427}), 12: (1, {'@': 427}), 13: (1, {'@': 427}), 14: (1, {'@': 427}), 15: (1, {'@': 427}), 16: (1, {'@': 427}), 17: (1, {'@': 427}), 18: (1, {'@': 427}), 19: (1, {'@': 427}), 20: (1, {'@': 427}), 21: (1, {'@': 427}), 22: (1, {'@': 427}), 23: (1, {'@': 427}), 24: (1, {'@': 427}), 25: (1, {'@': 427}), 26: (1, {'@': 427}), 27: (1, {'@': 427}), 28: (1, {'@': 427}), 29: (1, {'@': 427}), 30: (1, {'@': 427}), 31: (1, {'@': 427}), 32: (1, {'@': 427}), 33: (1, {'@': 427}), 34: (1, {'@': 427}), 35: (1, {'@': 427}), 36: (1, {'@': 427}), 37: (1, {'@': 427}), 38: (1, {'@': 427}), 39: (1, {'@': 427}), 40: (1, {'@': 427}), 41: (1, {'@': 427}), 42: (1, {'@': 427}), 43: (1, {'@': 427}), 44: (1, {'@': 427}), 45: (1, {'@': 427}), 46: (1, {'@': 427}), 47: (1, {'@': 427}), 48: (1, {'@': 427}), 49: (1, {'@': 427}), 50: (1, {'@': 427}), 51: (1, {'@': 427}), 52: (1, {'@': 427}), 53: (1, {'@': 427}), 54: (1, {'@': 427}), 55: (1, {'@': 427}), 56: (1, {'@': 427}), 57: (1, {'@': 427}), 58: (1, {'@': 427}), 59: (1, {'@': 427}), 60: (1, {'@': 427}), 61: (1, {'@': 427}), 62: (1, {'@': 427}), 63: (1, {'@': 427}), 64: (1, {'@': 427}), 65: (1, {'@': 427}), 66: (1, {'@': 427}), 67: (1, {'@': 427}), 68: (1, {'@': 427}), 69: (1, {'@': 427}), 70: (1, {'@': 427}), 71: (1, {'@': 427}), 72: (1, {'@': 427}), 73: (1, {'@': 427}), 74: (1, {'@': 427}), 75: (1, {'@': 427})}, 973: {0: (1, {'@': 424}), 1: (1, {'@': 424}), 2: (1, {'@': 424}), 3: (1, {'@': 424}), 4: (1, {'@': 424}), 5: (1, {'@': 424}), 6: (1, {'@': 424}), 7: (1, {'@': 424}), 8: (1, {'@': 424}), 9: (1, {'@': 424}), 10: (1, {'@': 424}), 11: (1, {'@': 424}), 12: (1, {'@': 424}), 13: (1, {'@': 424}), 14: (1, {'@': 424}), 15: (1, {'@': 424}), 16: (1, {'@': 424}), 17: (1, {'@': 424}), 18: (1, {'@': 424}), 19: (1, {'@': 424}), 20: (1, {'@': 424}), 21: (1, {'@': 424}), 22: (1, {'@': 424}), 23: (1, {'@': 424}), 24: (1, {'@': 424}), 25: (1, {'@': 424}), 26: (1, {'@': 424}), 27: (1, {'@': 424}), 28: (1, {'@': 424}), 29: (1, {'@': 424}), 30: (1, {'@': 424}), 31: (1, {'@': 424}), 32: (1, {'@': 424}), 33: (1, {'@': 424}), 34: (1, {'@': 424}), 35: (1, {'@': 424}), 36: (1, {'@': 424}), 37: (1, {'@': 424}), 38: (1, {'@': 424}), 39: (1, {'@': 424}), 40: (1, {'@': 424}), 41: (1, {'@': 424}), 42: (1, {'@': 424}), 43: (1, {'@': 424}), 44: (1, {'@': 424}), 45: (1, {'@': 424}), 46: (1, {'@': 424}), 47: (1, {'@': 424}), 48: (1, {'@': 424}), 49: (1, {'@': 424}), 50: (1, {'@': 424}), 51: (1, {'@': 424}), 52: (1, {'@': 424}), 53: (1, {'@': 424}), 54: (1, {'@': 424}), 55: (1, {'@': 424}), 56: (1, {'@': 424}), 57: (1, {'@': 424}), 58: (1, {'@': 424}), 59: (1, {'@': 424}), 60: (1, {'@': 424}), 61: (1, {'@': 424}), 62: (1, {'@': 424}), 63: (1, {'@': 424}), 64: (1, {'@': 424}), 65: (1, {'@': 424}), 66: (1, {'@': 424}), 67: (1, {'@': 424}), 68: (1, {'@': 424}), 69: (1, {'@': 424}), 70: (1, {'@': 424}), 71: (1, {'@': 424}), 72: (1, {'@': 424}), 73: (1, {'@': 424}), 74: (1, {'@': 424}), 75: (1, {'@': 424})}, 974: {590: (0, 418)}, 975: {0: (1, {'@': 429}), 1: (1, {'@': 429}), 2: (1, {'@': 429}), 3: (1, {'@': 429}), 4: (1, {'@': 429}), 5: (1, {'@': 429}), 6: (1, {'@': 429}), 7: (1, {'@': 429}), 8: (1, {'@': 429}), 9: (1, {'@': 429}), 10: (1, {'@': 429}), 11: (1, {'@': 429}), 12: (1, {'@': 429}), 13: (1, {'@': 429}), 14: (1, {'@': 429}), 15: (1, {'@': 429}), 16: (1, {'@': 429}), 17: (1, {'@': 429}), 18: (1, {'@': 429}), 19: (1, {'@': 429}), 20: (1, {'@': 429}), 21: (1, {'@': 429}), 22: (1, {'@': 429}), 23: (1, {'@': 429}), 24: (1, {'@': 429}), 25: (1, {'@': 429}), 26: (1, {'@': 429}), 27: (1, {'@': 429}), 28: (1, {'@': 429}), 29: (1, {'@': 429}), 30: (1, {'@': 429}), 31: (1, {'@': 429}), 32: (1, {'@': 429}), 33: (1, {'@': 429}), 34: (1, {'@': 429}), 35: (1, {'@': 429}), 36: (1, {'@': 429}), 37: (1, {'@': 429}), 38: (1, {'@': 429}), 39: (1, {'@': 429}), 40: (1, {'@': 429}), 41: (1, {'@': 429}), 42: (1, {'@': 429}), 43: (1, {'@': 429}), 44: (1, {'@': 429}), 45: (1, {'@': 429}), 46: (1, {'@': 429}), 47: (1, {'@': 429}), 48: (1, {'@': 429}), 49: (1, {'@': 429}), 50: (1, {'@': 429}), 51: (1, {'@': 429}), 52: (1, {'@': 429}), 53: (1, {'@': 429}), 54: (1, {'@': 429}), 55: (1, {'@': 429}), 56: (1, {'@': 429}), 57: (1, {'@': 429}), 58: (1, {'@': 429}), 59: (1, {'@': 429}), 60: (1, {'@': 429}), 61: (1, {'@': 429}), 62: (1, {'@': 429}), 63: (1, {'@': 429}), 64: (1, {'@': 429}), 65: (1, {'@': 429}), 66: (1, {'@': 429}), 67: (1, {'@': 429}), 68: (1, {'@': 429}), 69: (1, {'@': 429}), 70: (1, {'@': 429}), 71: (1, {'@': 429}), 72: (1, {'@': 429}), 73: (1, {'@': 429}), 74: (1, {'@': 429}), 75: (1, {'@': 429})}, 976: {57: (1, {'@': 628}), 60: (1, {'@': 628}), 6: (1, {'@': 628}), 7: (1, {'@': 628}), 61: (1, {'@': 628}), 126: (1, {'@': 628}), 45: (1, {'@': 628}), 37: (1, {'@': 628}), 38: (1, {'@': 628}), 47: (1, {'@': 628}), 26: (1, {'@': 628}), 27: (1, {'@': 628}), 4: (1, {'@': 628}), 28: (1, {'@': 628}), 50: (1, {'@': 628}), 53: (1, {'@': 628}), 67: (1, {'@': 628}), 29: (1, {'@': 628}), 30: (1, {'@': 628}), 15: (1, {'@': 628}), 268: (1, {'@': 628}), 270: (1, {'@': 628}), 266: (1, {'@': 628}), 43: (1, {'@': 628}), 1: (1, {'@': 628}), 2: (1, {'@': 628}), 44: (1, {'@': 628}), 48: (1, {'@': 628}), 49: (1, {'@': 628}), 51: (1, {'@': 628}), 52: (1, {'@': 628}), 8: (1, {'@': 628}), 9: (1, {'@': 628}), 11: (1, {'@': 628}), 54: (1, {'@': 628}), 55: (1, {'@': 628}), 17: (1, {'@': 628}), 18: (1, {'@': 628}), 58: (1, {'@': 628}), 59: (1, {'@': 628}), 21: (1, {'@': 628}), 22: (1, {'@': 628}), 62: (1, {'@': 628}), 23: (1, {'@': 628}), 25: (1, {'@': 628}), 63: (1, {'@': 628}), 31: (1, {'@': 628}), 33: (1, {'@': 628}), 64: (1, {'@': 628}), 66: (1, {'@': 628}), 34: (1, {'@': 628}), 36: (1, {'@': 628}), 68: (1, {'@': 628}), 69: (1, {'@': 628}), 70: (1, {'@': 628}), 71: (1, {'@': 628}), 40: (1, {'@': 628}), 72: (1, {'@': 628}), 41: (1, {'@': 628}), 73: (1, {'@': 628}), 74: (1, {'@': 628}), 75: (1, {'@': 628})}, 977: {43: (1, {'@': 1611}), 0: (1, {'@': 1611}), 1: (1, {'@': 1611}), 2: (1, {'@': 1611}), 3: (1, {'@': 1611}), 44: (1, {'@': 1611}), 45: (1, {'@': 1611}), 46: (1, {'@': 1611}), 47: (1, {'@': 1611}), 48: (1, {'@': 1611}), 4: (1, {'@': 1611}), 49: (1, {'@': 1611}), 50: (1, {'@': 1611}), 51: (1, {'@': 1611}), 5: (1, {'@': 1611}), 6: (1, {'@': 1611}), 52: (1, {'@': 1611}), 8: (1, {'@': 1611}), 7: (1, {'@': 1611}), 9: (1, {'@': 1611}), 53: (1, {'@': 1611}), 10: (1, {'@': 1611}), 11: (1, {'@': 1611}), 35: (1, {'@': 1611}), 54: (1, {'@': 1611}), 12: (1, {'@': 1611}), 42: (1, {'@': 1611}), 13: (1, {'@': 1611}), 14: (1, {'@': 1611}), 55: (1, {'@': 1611}), 15: (1, {'@': 1611}), 16: (1, {'@': 1611}), 56: (1, {'@': 1611}), 18: (1, {'@': 1611}), 17: (1, {'@': 1611}), 57: (1, {'@': 1611}), 19: (1, {'@': 1611}), 20: (1, {'@': 1611}), 58: (1, {'@': 1611}), 59: (1, {'@': 1611}), 21: (1, {'@': 1611}), 22: (1, {'@': 1611}), 60: (1, {'@': 1611}), 61: (1, {'@': 1611}), 62: (1, {'@': 1611}), 23: (1, {'@': 1611}), 24: (1, {'@': 1611}), 25: (1, {'@': 1611}), 26: (1, {'@': 1611}), 63: (1, {'@': 1611}), 27: (1, {'@': 1611}), 28: (1, {'@': 1611}), 29: (1, {'@': 1611}), 30: (1, {'@': 1611}), 31: (1, {'@': 1611}), 32: (1, {'@': 1611}), 33: (1, {'@': 1611}), 64: (1, {'@': 1611}), 65: (1, {'@': 1611}), 66: (1, {'@': 1611}), 67: (1, {'@': 1611}), 34: (1, {'@': 1611}), 36: (1, {'@': 1611}), 37: (1, {'@': 1611}), 68: (1, {'@': 1611}), 38: (1, {'@': 1611}), 69: (1, {'@': 1611}), 70: (1, {'@': 1611}), 71: (1, {'@': 1611}), 40: (1, {'@': 1611}), 72: (1, {'@': 1611}), 39: (1, {'@': 1611}), 41: (1, {'@': 1611}), 73: (1, {'@': 1611}), 74: (1, {'@': 1611}), 75: (1, {'@': 1611})}, 978: {409: (0, 2241), 407: (0, 1414)}, 979: {0: (1, {'@': 431}), 1: (1, {'@': 431}), 2: (1, {'@': 431}), 3: (1, {'@': 431}), 4: (1, {'@': 431}), 5: (1, {'@': 431}), 6: (1, {'@': 431}), 7: (1, {'@': 431}), 8: (1, {'@': 431}), 9: (1, {'@': 431}), 10: (1, {'@': 431}), 11: (1, {'@': 431}), 12: (1, {'@': 431}), 13: (1, {'@': 431}), 14: (1, {'@': 431}), 15: (1, {'@': 431}), 16: (1, {'@': 431}), 17: (1, {'@': 431}), 18: (1, {'@': 431}), 19: (1, {'@': 431}), 20: (1, {'@': 431}), 21: (1, {'@': 431}), 22: (1, {'@': 431}), 23: (1, {'@': 431}), 24: (1, {'@': 431}), 25: (1, {'@': 431}), 26: (1, {'@': 431}), 27: (1, {'@': 431}), 28: (1, {'@': 431}), 29: (1, {'@': 431}), 30: (1, {'@': 431}), 31: (1, {'@': 431}), 32: (1, {'@': 431}), 33: (1, {'@': 431}), 34: (1, {'@': 431}), 35: (1, {'@': 431}), 36: (1, {'@': 431}), 37: (1, {'@': 431}), 38: (1, {'@': 431}), 39: (1, {'@': 431}), 40: (1, {'@': 431}), 41: (1, {'@': 431}), 42: (1, {'@': 431}), 43: (1, {'@': 431}), 44: (1, {'@': 431}), 45: (1, {'@': 431}), 46: (1, {'@': 431}), 47: (1, {'@': 431}), 48: (1, {'@': 431}), 49: (1, {'@': 431}), 50: (1, {'@': 431}), 51: (1, {'@': 431}), 52: (1, {'@': 431}), 53: (1, {'@': 431}), 54: (1, {'@': 431}), 55: (1, {'@': 431}), 56: (1, {'@': 431}), 57: (1, {'@': 431}), 58: (1, {'@': 431}), 59: (1, {'@': 431}), 60: (1, {'@': 431}), 61: (1, {'@': 431}), 62: (1, {'@': 431}), 63: (1, {'@': 431}), 64: (1, {'@': 431}), 65: (1, {'@': 431}), 66: (1, {'@': 431}), 67: (1, {'@': 431}), 68: (1, {'@': 431}), 69: (1, {'@': 431}), 70: (1, {'@': 431}), 71: (1, {'@': 431}), 72: (1, {'@': 431}), 73: (1, {'@': 431}), 74: (1, {'@': 431}), 75: (1, {'@': 431})}, 980: {77: (0, 17), 78: (0, 1960), 79: (0, 1973), 12: (0, 396), 81: (0, 2295), 82: (0, 791), 312: (0, 1417), 83: (0, 809), 84: (0, 811), 85: (0, 816), 10: (0, 826), 313: (0, 2377), 591: (0, 1420), 87: (0, 842), 35: (0, 844), 88: (0, 848), 89: (0, 2384), 90: (0, 853), 91: (0, 863), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 56: (0, 783), 95: (0, 786), 96: (0, 789), 97: (0, 2370), 98: (0, 793), 19: (0, 800), 13: (0, 802), 592: (0, 1422), 32: (0, 807), 99: (0, 812), 100: (0, 817), 20: (0, 822), 102: (0, 823), 103: (0, 825), 105: (0, 830), 65: (0, 834), 106: (0, 838), 107: (0, 2409), 108: (0, 400), 109: (0, 390), 46: (0, 781), 80: (0, 2414), 593: (0, 1425), 110: (0, 799), 111: (0, 821), 14: (0, 399), 112: (0, 2376), 113: (0, 828), 114: (0, 832), 0: (0, 846), 194: (0, 1428), 594: (0, 1431), 42: (0, 858), 595: (0, 1436), 39: (0, 860), 115: (0, 44), 86: (0, 1437), 116: (0, 780), 5: (0, 787), 117: (0, 804), 24: (0, 814), 118: (0, 819), 596: (0, 1440), 597: (0, 1444), 119: (0, 836), 120: (0, 840), 122: (0, 850), 3: (0, 855), 123: (0, 856), 124: (0, 864)}, 981: {0: (1, {'@': 421}), 1: (1, {'@': 421}), 2: (1, {'@': 421}), 3: (1, {'@': 421}), 4: (1, {'@': 421}), 5: (1, {'@': 421}), 6: (1, {'@': 421}), 7: (1, {'@': 421}), 8: (1, {'@': 421}), 9: (1, {'@': 421}), 10: (1, {'@': 421}), 11: (1, {'@': 421}), 12: (1, {'@': 421}), 13: (1, {'@': 421}), 14: (1, {'@': 421}), 15: (1, {'@': 421}), 16: (1, {'@': 421}), 17: (1, {'@': 421}), 18: (1, {'@': 421}), 19: (1, {'@': 421}), 20: (1, {'@': 421}), 21: (1, {'@': 421}), 22: (1, {'@': 421}), 23: (1, {'@': 421}), 24: (1, {'@': 421}), 25: (1, {'@': 421}), 26: (1, {'@': 421}), 27: (1, {'@': 421}), 28: (1, {'@': 421}), 29: (1, {'@': 421}), 30: (1, {'@': 421}), 31: (1, {'@': 421}), 32: (1, {'@': 421}), 33: (1, {'@': 421}), 34: (1, {'@': 421}), 35: (1, {'@': 421}), 36: (1, {'@': 421}), 37: (1, {'@': 421}), 38: (1, {'@': 421}), 39: (1, {'@': 421}), 40: (1, {'@': 421}), 41: (1, {'@': 421}), 42: (1, {'@': 421}), 43: (1, {'@': 421}), 44: (1, {'@': 421}), 45: (1, {'@': 421}), 46: (1, {'@': 421}), 47: (1, {'@': 421}), 48: (1, {'@': 421}), 49: (1, {'@': 421}), 50: (1, {'@': 421}), 51: (1, {'@': 421}), 52: (1, {'@': 421}), 53: (1, {'@': 421}), 54: (1, {'@': 421}), 55: (1, {'@': 421}), 56: (1, {'@': 421}), 57: (1, {'@': 421}), 58: (1, {'@': 421}), 59: (1, {'@': 421}), 60: (1, {'@': 421}), 61: (1, {'@': 421}), 62: (1, {'@': 421}), 63: (1, {'@': 421}), 64: (1, {'@': 421}), 65: (1, {'@': 421}), 66: (1, {'@': 421}), 67: (1, {'@': 421}), 68: (1, {'@': 421}), 69: (1, {'@': 421}), 70: (1, {'@': 421}), 71: (1, {'@': 421}), 72: (1, {'@': 421}), 73: (1, {'@': 421}), 74: (1, {'@': 421}), 75: (1, {'@': 421})}, 982: {6: (1, {'@': 1673}), 60: (1, {'@': 1673}), 7: (1, {'@': 1673}), 126: (1, {'@': 1673}), 61: (1, {'@': 1673}), 45: (1, {'@': 1673}), 37: (1, {'@': 1673}), 38: (1, {'@': 1673}), 47: (1, {'@': 1673}), 26: (1, {'@': 1673}), 27: (1, {'@': 1673}), 4: (1, {'@': 1673}), 28: (1, {'@': 1673}), 50: (1, {'@': 1673}), 57: (1, {'@': 1673})}, 983: {0: (1, {'@': 436}), 1: (1, {'@': 436}), 2: (1, {'@': 436}), 3: (1, {'@': 436}), 4: (1, {'@': 436}), 5: (1, {'@': 436}), 6: (1, {'@': 436}), 7: (1, {'@': 436}), 8: (1, {'@': 436}), 9: (1, {'@': 436}), 10: (1, {'@': 436}), 11: (1, {'@': 436}), 12: (1, {'@': 436}), 13: (1, {'@': 436}), 14: (1, {'@': 436}), 15: (1, {'@': 436}), 16: (1, {'@': 436}), 17: (1, {'@': 436}), 18: (1, {'@': 436}), 19: (1, {'@': 436}), 20: (1, {'@': 436}), 21: (1, {'@': 436}), 22: (1, {'@': 436}), 23: (1, {'@': 436}), 24: (1, {'@': 436}), 25: (1, {'@': 436}), 26: (1, {'@': 436}), 27: (1, {'@': 436}), 28: (1, {'@': 436}), 29: (1, {'@': 436}), 30: (1, {'@': 436}), 31: (1, {'@': 436}), 32: (1, {'@': 436}), 33: (1, {'@': 436}), 34: (1, {'@': 436}), 35: (1, {'@': 436}), 36: (1, {'@': 436}), 37: (1, {'@': 436}), 38: (1, {'@': 436}), 39: (1, {'@': 436}), 40: (1, {'@': 436}), 41: (1, {'@': 436}), 42: (1, {'@': 436}), 43: (1, {'@': 436}), 44: (1, {'@': 436}), 45: (1, {'@': 436}), 46: (1, {'@': 436}), 47: (1, {'@': 436}), 48: (1, {'@': 436}), 49: (1, {'@': 436}), 50: (1, {'@': 436}), 51: (1, {'@': 436}), 52: (1, {'@': 436}), 53: (1, {'@': 436}), 54: (1, {'@': 436}), 55: (1, {'@': 436}), 56: (1, {'@': 436}), 57: (1, {'@': 436}), 58: (1, {'@': 436}), 59: (1, {'@': 436}), 60: (1, {'@': 436}), 61: (1, {'@': 436}), 62: (1, {'@': 436}), 63: (1, {'@': 436}), 64: (1, {'@': 436}), 65: (1, {'@': 436}), 66: (1, {'@': 436}), 67: (1, {'@': 436}), 68: (1, {'@': 436}), 69: (1, {'@': 436}), 70: (1, {'@': 436}), 71: (1, {'@': 436}), 72: (1, {'@': 436}), 73: (1, {'@': 436}), 74: (1, {'@': 436}), 75: (1, {'@': 436})}, 984: {0: (1, {'@': 422}), 1: (1, {'@': 422}), 2: (1, {'@': 422}), 3: (1, {'@': 422}), 4: (1, {'@': 422}), 5: (1, {'@': 422}), 6: (1, {'@': 422}), 7: (1, {'@': 422}), 8: (1, {'@': 422}), 9: (1, {'@': 422}), 10: (1, {'@': 422}), 11: (1, {'@': 422}), 12: (1, {'@': 422}), 13: (1, {'@': 422}), 14: (1, {'@': 422}), 15: (1, {'@': 422}), 16: (1, {'@': 422}), 17: (1, {'@': 422}), 18: (1, {'@': 422}), 19: (1, {'@': 422}), 20: (1, {'@': 422}), 21: (1, {'@': 422}), 22: (1, {'@': 422}), 23: (1, {'@': 422}), 24: (1, {'@': 422}), 25: (1, {'@': 422}), 26: (1, {'@': 422}), 27: (1, {'@': 422}), 28: (1, {'@': 422}), 29: (1, {'@': 422}), 30: (1, {'@': 422}), 31: (1, {'@': 422}), 32: (1, {'@': 422}), 33: (1, {'@': 422}), 34: (1, {'@': 422}), 35: (1, {'@': 422}), 36: (1, {'@': 422}), 37: (1, {'@': 422}), 38: (1, {'@': 422}), 39: (1, {'@': 422}), 40: (1, {'@': 422}), 41: (1, {'@': 422}), 42: (1, {'@': 422}), 43: (1, {'@': 422}), 44: (1, {'@': 422}), 45: (1, {'@': 422}), 46: (1, {'@': 422}), 47: (1, {'@': 422}), 48: (1, {'@': 422}), 49: (1, {'@': 422}), 50: (1, {'@': 422}), 51: (1, {'@': 422}), 52: (1, {'@': 422}), 53: (1, {'@': 422}), 54: (1, {'@': 422}), 55: (1, {'@': 422}), 56: (1, {'@': 422}), 57: (1, {'@': 422}), 58: (1, {'@': 422}), 59: (1, {'@': 422}), 60: (1, {'@': 422}), 61: (1, {'@': 422}), 62: (1, {'@': 422}), 63: (1, {'@': 422}), 64: (1, {'@': 422}), 65: (1, {'@': 422}), 66: (1, {'@': 422}), 67: (1, {'@': 422}), 68: (1, {'@': 422}), 69: (1, {'@': 422}), 70: (1, {'@': 422}), 71: (1, {'@': 422}), 72: (1, {'@': 422}), 73: (1, {'@': 422}), 74: (1, {'@': 422}), 75: (1, {'@': 422})}, 985: {598: (0, 1455), 599: (0, 2304), 600: (0, 2300)}, 986: {0: (1, {'@': 423}), 1: (1, {'@': 423}), 2: (1, {'@': 423}), 3: (1, {'@': 423}), 4: (1, {'@': 423}), 5: (1, {'@': 423}), 6: (1, {'@': 423}), 7: (1, {'@': 423}), 8: (1, {'@': 423}), 9: (1, {'@': 423}), 10: (1, {'@': 423}), 11: (1, {'@': 423}), 12: (1, {'@': 423}), 13: (1, {'@': 423}), 14: (1, {'@': 423}), 15: (1, {'@': 423}), 16: (1, {'@': 423}), 17: (1, {'@': 423}), 18: (1, {'@': 423}), 19: (1, {'@': 423}), 20: (1, {'@': 423}), 21: (1, {'@': 423}), 22: (1, {'@': 423}), 23: (1, {'@': 423}), 24: (1, {'@': 423}), 25: (1, {'@': 423}), 26: (1, {'@': 423}), 27: (1, {'@': 423}), 28: (1, {'@': 423}), 29: (1, {'@': 423}), 30: (1, {'@': 423}), 31: (1, {'@': 423}), 32: (1, {'@': 423}), 33: (1, {'@': 423}), 34: (1, {'@': 423}), 35: (1, {'@': 423}), 36: (1, {'@': 423}), 37: (1, {'@': 423}), 38: (1, {'@': 423}), 39: (1, {'@': 423}), 40: (1, {'@': 423}), 41: (1, {'@': 423}), 42: (1, {'@': 423}), 43: (1, {'@': 423}), 44: (1, {'@': 423}), 45: (1, {'@': 423}), 46: (1, {'@': 423}), 47: (1, {'@': 423}), 48: (1, {'@': 423}), 49: (1, {'@': 423}), 50: (1, {'@': 423}), 51: (1, {'@': 423}), 52: (1, {'@': 423}), 53: (1, {'@': 423}), 54: (1, {'@': 423}), 55: (1, {'@': 423}), 56: (1, {'@': 423}), 57: (1, {'@': 423}), 58: (1, {'@': 423}), 59: (1, {'@': 423}), 60: (1, {'@': 423}), 61: (1, {'@': 423}), 62: (1, {'@': 423}), 63: (1, {'@': 423}), 64: (1, {'@': 423}), 65: (1, {'@': 423}), 66: (1, {'@': 423}), 67: (1, {'@': 423}), 68: (1, {'@': 423}), 69: (1, {'@': 423}), 70: (1, {'@': 423}), 71: (1, {'@': 423}), 72: (1, {'@': 423}), 73: (1, {'@': 423}), 74: (1, {'@': 423}), 75: (1, {'@': 423})}, 987: {126: (0, 1411), 146: (1, {'@': 958})}, 988: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 601: (0, 2258), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 602: (0, 2268), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 603: (0, 2276), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 604: (0, 2283), 86: (0, 2286), 119: (0, 836), 106: (0, 838), 605: (0, 2294), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 606: (0, 2119), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 989: {0: (1, {'@': 425}), 1: (1, {'@': 425}), 2: (1, {'@': 425}), 3: (1, {'@': 425}), 4: (1, {'@': 425}), 5: (1, {'@': 425}), 6: (1, {'@': 425}), 7: (1, {'@': 425}), 8: (1, {'@': 425}), 9: (1, {'@': 425}), 10: (1, {'@': 425}), 11: (1, {'@': 425}), 12: (1, {'@': 425}), 13: (1, {'@': 425}), 14: (1, {'@': 425}), 15: (1, {'@': 425}), 16: (1, {'@': 425}), 17: (1, {'@': 425}), 18: (1, {'@': 425}), 19: (1, {'@': 425}), 20: (1, {'@': 425}), 21: (1, {'@': 425}), 22: (1, {'@': 425}), 23: (1, {'@': 425}), 24: (1, {'@': 425}), 25: (1, {'@': 425}), 26: (1, {'@': 425}), 27: (1, {'@': 425}), 28: (1, {'@': 425}), 29: (1, {'@': 425}), 30: (1, {'@': 425}), 31: (1, {'@': 425}), 32: (1, {'@': 425}), 33: (1, {'@': 425}), 34: (1, {'@': 425}), 35: (1, {'@': 425}), 36: (1, {'@': 425}), 37: (1, {'@': 425}), 38: (1, {'@': 425}), 39: (1, {'@': 425}), 40: (1, {'@': 425}), 41: (1, {'@': 425}), 42: (1, {'@': 425}), 43: (1, {'@': 425}), 44: (1, {'@': 425}), 45: (1, {'@': 425}), 46: (1, {'@': 425}), 47: (1, {'@': 425}), 48: (1, {'@': 425}), 49: (1, {'@': 425}), 50: (1, {'@': 425}), 51: (1, {'@': 425}), 52: (1, {'@': 425}), 53: (1, {'@': 425}), 54: (1, {'@': 425}), 55: (1, {'@': 425}), 56: (1, {'@': 425}), 57: (1, {'@': 425}), 58: (1, {'@': 425}), 59: (1, {'@': 425}), 60: (1, {'@': 425}), 61: (1, {'@': 425}), 62: (1, {'@': 425}), 63: (1, {'@': 425}), 64: (1, {'@': 425}), 65: (1, {'@': 425}), 66: (1, {'@': 425}), 67: (1, {'@': 425}), 68: (1, {'@': 425}), 69: (1, {'@': 425}), 70: (1, {'@': 425}), 71: (1, {'@': 425}), 72: (1, {'@': 425}), 73: (1, {'@': 425}), 74: (1, {'@': 425}), 75: (1, {'@': 425})}, 990: {144: (0, 2316), 145: (0, 447)}, 991: {0: (1, {'@': 420}), 1: (1, {'@': 420}), 2: (1, {'@': 420}), 3: (1, {'@': 420}), 4: (1, {'@': 420}), 5: (1, {'@': 420}), 6: (1, {'@': 420}), 7: (1, {'@': 420}), 8: (1, {'@': 420}), 9: (1, {'@': 420}), 10: (1, {'@': 420}), 11: (1, {'@': 420}), 12: (1, {'@': 420}), 13: (1, {'@': 420}), 14: (1, {'@': 420}), 15: (1, {'@': 420}), 16: (1, {'@': 420}), 17: (1, {'@': 420}), 18: (1, {'@': 420}), 19: (1, {'@': 420}), 20: (1, {'@': 420}), 21: (1, {'@': 420}), 22: (1, {'@': 420}), 23: (1, {'@': 420}), 24: (1, {'@': 420}), 25: (1, {'@': 420}), 26: (1, {'@': 420}), 27: (1, {'@': 420}), 28: (1, {'@': 420}), 29: (1, {'@': 420}), 30: (1, {'@': 420}), 31: (1, {'@': 420}), 32: (1, {'@': 420}), 33: (1, {'@': 420}), 34: (1, {'@': 420}), 35: (1, {'@': 420}), 36: (1, {'@': 420}), 37: (1, {'@': 420}), 38: (1, {'@': 420}), 39: (1, {'@': 420}), 40: (1, {'@': 420}), 41: (1, {'@': 420}), 42: (1, {'@': 420}), 43: (1, {'@': 420}), 44: (1, {'@': 420}), 45: (1, {'@': 420}), 46: (1, {'@': 420}), 47: (1, {'@': 420}), 48: (1, {'@': 420}), 49: (1, {'@': 420}), 50: (1, {'@': 420}), 51: (1, {'@': 420}), 52: (1, {'@': 420}), 53: (1, {'@': 420}), 54: (1, {'@': 420}), 55: (1, {'@': 420}), 56: (1, {'@': 420}), 57: (1, {'@': 420}), 58: (1, {'@': 420}), 59: (1, {'@': 420}), 60: (1, {'@': 420}), 61: (1, {'@': 420}), 62: (1, {'@': 420}), 63: (1, {'@': 420}), 64: (1, {'@': 420}), 65: (1, {'@': 420}), 66: (1, {'@': 420}), 67: (1, {'@': 420}), 68: (1, {'@': 420}), 69: (1, {'@': 420}), 70: (1, {'@': 420}), 71: (1, {'@': 420}), 72: (1, {'@': 420}), 73: (1, {'@': 420}), 74: (1, {'@': 420}), 75: (1, {'@': 420})}, 992: {462: (0, 2433), 607: (0, 452), 144: (0, 192), 454: (0, 195)}, 993: {268: (1, {'@': 618}), 60: (1, {'@': 618}), 126: (1, {'@': 618}), 67: (1, {'@': 618}), 270: (1, {'@': 618}), 4: (1, {'@': 618}), 266: (1, {'@': 618}), 30: (1, {'@': 618}), 57: (1, {'@': 618})}, 994: {6: (1, {'@': 957}), 60: (1, {'@': 957}), 7: (1, {'@': 957}), 61: (1, {'@': 957}), 126: (1, {'@': 957}), 45: (1, {'@': 957}), 37: (1, {'@': 957}), 38: (1, {'@': 957}), 47: (1, {'@': 957}), 26: (1, {'@': 957}), 27: (1, {'@': 957}), 4: (1, {'@': 957}), 28: (1, {'@': 957}), 50: (1, {'@': 957}), 57: (1, {'@': 957}), 43: (1, {'@': 957}), 1: (1, {'@': 957}), 2: (1, {'@': 957}), 44: (1, {'@': 957}), 48: (1, {'@': 957}), 49: (1, {'@': 957}), 51: (1, {'@': 957}), 52: (1, {'@': 957}), 8: (1, {'@': 957}), 9: (1, {'@': 957}), 53: (1, {'@': 957}), 11: (1, {'@': 957}), 54: (1, {'@': 957}), 55: (1, {'@': 957}), 15: (1, {'@': 957}), 17: (1, {'@': 957}), 18: (1, {'@': 957}), 58: (1, {'@': 957}), 59: (1, {'@': 957}), 21: (1, {'@': 957}), 22: (1, {'@': 957}), 62: (1, {'@': 957}), 23: (1, {'@': 957}), 25: (1, {'@': 957}), 63: (1, {'@': 957}), 29: (1, {'@': 957}), 30: (1, {'@': 957}), 31: (1, {'@': 957}), 33: (1, {'@': 957}), 64: (1, {'@': 957}), 66: (1, {'@': 957}), 67: (1, {'@': 957}), 34: (1, {'@': 957}), 36: (1, {'@': 957}), 68: (1, {'@': 957}), 69: (1, {'@': 957}), 70: (1, {'@': 957}), 71: (1, {'@': 957}), 40: (1, {'@': 957}), 72: (1, {'@': 957}), 41: (1, {'@': 957}), 73: (1, {'@': 957}), 74: (1, {'@': 957}), 75: (1, {'@': 957})}, 995: {192: (0, 2596), 193: (0, 53), 126: (0, 85), 57: (1, {'@': 763}), 60: (1, {'@': 763})}, 996: {608: (0, 2245), 609: (0, 2291), 610: (0, 1452), 611: (0, 2249), 612: (0, 2253), 613: (0, 2299)}, 997: {112: (0, 2600), 126: (1, {'@': 808}), 193: (1, {'@': 808}), 57: (1, {'@': 808}), 60: (1, {'@': 808})}, 998: {57: (1, {'@': 1460}), 60: (1, {'@': 1460}), 6: (1, {'@': 1460}), 7: (1, {'@': 1460}), 61: (1, {'@': 1460}), 126: (1, {'@': 1460}), 45: (1, {'@': 1460}), 37: (1, {'@': 1460}), 38: (1, {'@': 1460}), 47: (1, {'@': 1460}), 26: (1, {'@': 1460}), 27: (1, {'@': 1460}), 4: (1, {'@': 1460}), 28: (1, {'@': 1460}), 50: (1, {'@': 1460}), 53: (1, {'@': 1460}), 67: (1, {'@': 1460}), 29: (1, {'@': 1460}), 30: (1, {'@': 1460}), 15: (1, {'@': 1460}), 43: (1, {'@': 1460}), 21: (1, {'@': 1460}), 44: (1, {'@': 1460}), 33: (1, {'@': 1460}), 64: (1, {'@': 1460}), 34: (1, {'@': 1460}), 54: (1, {'@': 1460}), 69: (1, {'@': 1460}), 40: (1, {'@': 1460}), 74: (1, {'@': 1460}), 41: (1, {'@': 1460}), 75: (1, {'@': 1460}), 18: (1, {'@': 1460}), 1: (1, {'@': 1460}), 2: (1, {'@': 1460}), 48: (1, {'@': 1460}), 49: (1, {'@': 1460}), 51: (1, {'@': 1460}), 52: (1, {'@': 1460}), 8: (1, {'@': 1460}), 9: (1, {'@': 1460}), 11: (1, {'@': 1460}), 55: (1, {'@': 1460}), 17: (1, {'@': 1460}), 58: (1, {'@': 1460}), 59: (1, {'@': 1460}), 22: (1, {'@': 1460}), 62: (1, {'@': 1460}), 23: (1, {'@': 1460}), 25: (1, {'@': 1460}), 63: (1, {'@': 1460}), 31: (1, {'@': 1460}), 66: (1, {'@': 1460}), 36: (1, {'@': 1460}), 68: (1, {'@': 1460}), 70: (1, {'@': 1460}), 71: (1, {'@': 1460}), 72: (1, {'@': 1460}), 73: (1, {'@': 1460})}, 999: {260: (0, 997), 126: (0, 2455), 263: (0, 1013), 262: (0, 2446), 261: (0, 2445), 57: (1, {'@': 797}), 60: (1, {'@': 797})}, 1000: {614: (0, 1089), 77: (0, 17), 615: (0, 1090), 78: (0, 1960), 79: (0, 1973), 12: (0, 396), 86: (0, 1092), 81: (0, 2295), 82: (0, 791), 549: (0, 1093), 83: (0, 809), 84: (0, 811), 85: (0, 816), 10: (0, 826), 87: (0, 842), 35: (0, 844), 88: (0, 848), 89: (0, 2384), 90: (0, 853), 91: (0, 863), 144: (0, 2316), 546: (0, 1096), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 56: (0, 783), 95: (0, 786), 96: (0, 789), 547: (0, 1102), 97: (0, 2370), 98: (0, 793), 19: (0, 800), 13: (0, 802), 32: (0, 807), 99: (0, 812), 100: (0, 817), 20: (0, 822), 102: (0, 823), 103: (0, 825), 105: (0, 830), 65: (0, 834), 106: (0, 838), 107: (0, 2409), 108: (0, 400), 109: (0, 390), 46: (0, 781), 80: (0, 2414), 145: (0, 1104), 110: (0, 799), 111: (0, 821), 14: (0, 399), 112: (0, 2376), 113: (0, 828), 114: (0, 832), 0: (0, 846), 42: (0, 858), 39: (0, 860), 115: (0, 44), 116: (0, 780), 194: (0, 1106), 5: (0, 787), 548: (0, 1108), 117: (0, 804), 24: (0, 814), 118: (0, 819), 119: (0, 836), 120: (0, 840), 122: (0, 850), 550: (0, 1109), 3: (0, 855), 123: (0, 856), 124: (0, 864)}, 1001: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 429)}, 1002: {608: (0, 2245), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 611: (0, 2249), 94: (0, 1954), 16: (0, 391), 612: (0, 2253), 78: (0, 1960), 601: (0, 2258), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 606: (0, 2261), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 602: (0, 2268), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 610: (0, 2272), 603: (0, 2276), 84: (0, 811), 616: (0, 2280), 99: (0, 812), 24: (0, 814), 85: (0, 816), 118: (0, 819), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 111: (0, 821), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 604: (0, 2283), 86: (0, 2286), 42: (0, 858), 119: (0, 836), 106: (0, 838), 609: (0, 2291), 605: (0, 2294), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 39: (0, 860), 613: (0, 2299), 91: (0, 863), 124: (0, 864)}, 1003: {57: (1, {'@': 887}), 60: (1, {'@': 887}), 6: (1, {'@': 887}), 7: (1, {'@': 887}), 61: (1, {'@': 887}), 126: (1, {'@': 887}), 45: (1, {'@': 887}), 37: (1, {'@': 887}), 38: (1, {'@': 887}), 47: (1, {'@': 887}), 26: (1, {'@': 887}), 27: (1, {'@': 887}), 4: (1, {'@': 887}), 28: (1, {'@': 887}), 50: (1, {'@': 887}), 53: (1, {'@': 887}), 67: (1, {'@': 887}), 29: (1, {'@': 887}), 30: (1, {'@': 887}), 15: (1, {'@': 887}), 1: (1, {'@': 887}), 43: (1, {'@': 887}), 2: (1, {'@': 887}), 44: (1, {'@': 887}), 48: (1, {'@': 887}), 49: (1, {'@': 887}), 51: (1, {'@': 887}), 52: (1, {'@': 887}), 8: (1, {'@': 887}), 9: (1, {'@': 887}), 11: (1, {'@': 887}), 54: (1, {'@': 887}), 55: (1, {'@': 887}), 17: (1, {'@': 887}), 18: (1, {'@': 887}), 58: (1, {'@': 887}), 59: (1, {'@': 887}), 21: (1, {'@': 887}), 22: (1, {'@': 887}), 62: (1, {'@': 887}), 23: (1, {'@': 887}), 25: (1, {'@': 887}), 63: (1, {'@': 887}), 31: (1, {'@': 887}), 33: (1, {'@': 887}), 64: (1, {'@': 887}), 66: (1, {'@': 887}), 34: (1, {'@': 887}), 36: (1, {'@': 887}), 68: (1, {'@': 887}), 69: (1, {'@': 887}), 70: (1, {'@': 887}), 71: (1, {'@': 887}), 40: (1, {'@': 887}), 72: (1, {'@': 887}), 41: (1, {'@': 887}), 73: (1, {'@': 887}), 74: (1, {'@': 887}), 75: (1, {'@': 887})}, 1004: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 86: (0, 421), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1005: {126: (0, 55), 193: (0, 53), 192: (0, 2440), 57: (1, {'@': 795}), 60: (1, {'@': 795})}, 1006: {454: (0, 188), 455: (0, 210), 456: (0, 212), 457: (0, 213), 460: (0, 317), 458: (0, 215), 459: (0, 216), 461: (0, 219), 144: (0, 221), 462: (0, 223), 463: (0, 224)}, 1007: {60: (0, 2302)}, 1008: {193: (0, 53), 192: (0, 1482), 126: (0, 2439), 57: (1, {'@': 796}), 60: (1, {'@': 796})}, 1009: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 194: (0, 479), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 1010: {462: (0, 2433), 607: (0, 194), 144: (0, 192), 454: (0, 195)}, 1011: {6: (1, {'@': 952}), 60: (1, {'@': 952}), 7: (1, {'@': 952}), 61: (1, {'@': 952}), 126: (1, {'@': 952}), 45: (1, {'@': 952}), 37: (1, {'@': 952}), 38: (1, {'@': 952}), 47: (1, {'@': 952}), 26: (1, {'@': 952}), 27: (1, {'@': 952}), 4: (1, {'@': 952}), 28: (1, {'@': 952}), 50: (1, {'@': 952}), 57: (1, {'@': 952}), 43: (1, {'@': 952}), 1: (1, {'@': 952}), 2: (1, {'@': 952}), 44: (1, {'@': 952}), 48: (1, {'@': 952}), 49: (1, {'@': 952}), 51: (1, {'@': 952}), 52: (1, {'@': 952}), 8: (1, {'@': 952}), 9: (1, {'@': 952}), 53: (1, {'@': 952}), 11: (1, {'@': 952}), 54: (1, {'@': 952}), 55: (1, {'@': 952}), 15: (1, {'@': 952}), 17: (1, {'@': 952}), 18: (1, {'@': 952}), 58: (1, {'@': 952}), 59: (1, {'@': 952}), 21: (1, {'@': 952}), 22: (1, {'@': 952}), 62: (1, {'@': 952}), 23: (1, {'@': 952}), 25: (1, {'@': 952}), 63: (1, {'@': 952}), 29: (1, {'@': 952}), 30: (1, {'@': 952}), 31: (1, {'@': 952}), 33: (1, {'@': 952}), 64: (1, {'@': 952}), 66: (1, {'@': 952}), 67: (1, {'@': 952}), 34: (1, {'@': 952}), 36: (1, {'@': 952}), 68: (1, {'@': 952}), 69: (1, {'@': 952}), 70: (1, {'@': 952}), 71: (1, {'@': 952}), 40: (1, {'@': 952}), 72: (1, {'@': 952}), 41: (1, {'@': 952}), 73: (1, {'@': 952}), 74: (1, {'@': 952}), 75: (1, {'@': 952})}, 1012: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 432), 112: (0, 2376), 97: (0, 2370)}, 1013: {112: (0, 2459), 126: (1, {'@': 811}), 193: (1, {'@': 811}), 57: (1, {'@': 811}), 60: (1, {'@': 811})}, 1014: {60: (1, {'@': 793}), 57: (1, {'@': 793})}, 1015: {115: (0, 44), 77: (0, 17), 108: (0, 400), 311: (0, 2361), 86: (0, 460), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 310: (0, 463), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 314: (0, 2369), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1016: {112: (0, 56), 268: (1, {'@': 648}), 60: (1, {'@': 648}), 126: (1, {'@': 648}), 67: (1, {'@': 648}), 270: (1, {'@': 648}), 4: (1, {'@': 648}), 266: (1, {'@': 648}), 30: (1, {'@': 648}), 57: (1, {'@': 648})}, 1017: {265: (0, 993), 4: (0, 405), 266: (0, 1016), 268: (0, 1462), 617: (0, 2405), 269: (0, 1465), 267: (0, 2398), 67: (0, 1913), 166: (0, 1468), 126: (0, 2395), 270: (0, 1470), 30: (0, 1920), 162: (0, 1472), 161: (0, 1476), 272: (0, 1483), 57: (1, {'@': 614}), 60: (1, {'@': 614})}, 1018: {495: (0, 425), 618: (0, 427), 619: (0, 434)}, 1019: {126: (0, 436)}, 1020: {490: (0, 2317), 77: (0, 17), 115: (0, 44), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 492: (0, 2347), 79: (0, 1973), 116: (0, 780), 493: (0, 2351), 46: (0, 781), 494: (0, 2334), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 491: (0, 444), 84: (0, 811), 99: (0, 812), 86: (0, 2341), 24: (0, 814), 495: (0, 2354), 85: (0, 816), 111: (0, 821), 20: (0, 822), 102: (0, 823), 496: (0, 2343), 103: (0, 825), 14: (0, 399), 118: (0, 819), 10: (0, 826), 100: (0, 817), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1021: {80: (0, 2414), 81: (0, 2295), 194: (0, 2412), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 1022: {60: (1, {'@': 659}), 126: (1, {'@': 659}), 222: (1, {'@': 659}), 220: (1, {'@': 659}), 36: (1, {'@': 659}), 221: (1, {'@': 659}), 223: (1, {'@': 659}), 57: (1, {'@': 659})}, 1023: {60: (1, {'@': 1276})}, 1024: {60: (1, {'@': 1275})}, 1025: {60: (0, 1248)}, 1026: {60: (1, {'@': 1327}), 57: (1, {'@': 1327})}, 1027: {144: (0, 744)}, 1028: {298: (0, 995), 299: (0, 1524), 193: (0, 53), 192: (0, 1665), 300: (0, 1721), 146: (1, {'@': 378}), 60: (1, {'@': 761})}, 1029: {81: (0, 2295), 107: (0, 2409), 76: (0, 598), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 80: (0, 2149)}, 1030: {126: (0, 748), 60: (1, {'@': 1544}), 146: (1, {'@': 1544})}, 1031: {273: (0, 1715), 274: (0, 92), 275: (0, 98), 276: (0, 36), 277: (0, 1486), 278: (0, 1491), 279: (0, 1495), 146: (1, {'@': 364})}, 1032: {146: (0, 2301)}, 1033: {518: (0, 756), 512: (0, 2012), 513: (0, 1992), 514: (0, 1981), 515: (0, 1993), 516: (0, 1999), 517: (0, 2030), 519: (0, 2021)}, 1034: {57: (1, {'@': 516}), 60: (1, {'@': 516}), 126: (1, {'@': 516}), 536: (1, {'@': 516})}, 1035: {60: (0, 750)}, 1036: {60: (0, 752)}, 1037: {64: (0, 1537), 53: (0, 387), 41: (0, 372), 280: (0, 1542), 38: (0, 1811), 281: (0, 1545), 43: (0, 1548), 61: (0, 25), 165: (0, 1553), 69: (0, 1760), 45: (0, 1833), 282: (0, 1555), 204: (0, 1565), 185: (0, 1569), 208: (0, 1573), 6: (0, 20), 44: (0, 358), 40: (0, 1756), 168: (0, 1577), 33: (0, 383), 18: (0, 1581), 21: (0, 366), 283: (0, 1585), 34: (0, 1589), 28: (0, 33), 284: (0, 1594), 54: (0, 1598), 37: (0, 1828), 211: (0, 1602), 183: (0, 1607), 285: (0, 1610), 74: (0, 1616), 27: (0, 408), 172: (0, 1620), 167: (0, 1625), 200: (0, 1627), 210: (0, 1631), 164: (0, 1635), 286: (0, 1640), 75: (0, 341), 207: (0, 1646), 201: (0, 1650), 287: (0, 1654), 169: (0, 1657), 0: (1, {'@': 431}), 3: (1, {'@': 431}), 20: (1, {'@': 431}), 32: (1, {'@': 431}), 65: (1, {'@': 431}), 10: (1, {'@': 431}), 35: (1, {'@': 431}), 12: (1, {'@': 431}), 46: (1, {'@': 431}), 24: (1, {'@': 431}), 14: (1, {'@': 431}), 13: (1, {'@': 431}), 39: (1, {'@': 431}), 42: (1, {'@': 431}), 56: (1, {'@': 431}), 16: (1, {'@': 431}), 5: (1, {'@': 431}), 19: (1, {'@': 431}), 146: (1, {'@': 397}), 60: (1, {'@': 1026})}, 1038: {60: (0, 755)}, 1039: {126: (1, {'@': 1657}), 60: (1, {'@': 1657})}, 1040: {60: (0, 757)}, 1041: {57: (1, {'@': 1158}), 60: (1, {'@': 1158}), 43: (1, {'@': 1158}), 1: (1, {'@': 1158}), 2: (1, {'@': 1158}), 44: (1, {'@': 1158}), 45: (1, {'@': 1158}), 47: (1, {'@': 1158}), 48: (1, {'@': 1158}), 4: (1, {'@': 1158}), 49: (1, {'@': 1158}), 50: (1, {'@': 1158}), 51: (1, {'@': 1158}), 6: (1, {'@': 1158}), 52: (1, {'@': 1158}), 8: (1, {'@': 1158}), 7: (1, {'@': 1158}), 9: (1, {'@': 1158}), 53: (1, {'@': 1158}), 11: (1, {'@': 1158}), 54: (1, {'@': 1158}), 55: (1, {'@': 1158}), 15: (1, {'@': 1158}), 17: (1, {'@': 1158}), 18: (1, {'@': 1158}), 58: (1, {'@': 1158}), 59: (1, {'@': 1158}), 21: (1, {'@': 1158}), 22: (1, {'@': 1158}), 61: (1, {'@': 1158}), 126: (1, {'@': 1158}), 62: (1, {'@': 1158}), 23: (1, {'@': 1158}), 25: (1, {'@': 1158}), 26: (1, {'@': 1158}), 63: (1, {'@': 1158}), 27: (1, {'@': 1158}), 28: (1, {'@': 1158}), 29: (1, {'@': 1158}), 30: (1, {'@': 1158}), 31: (1, {'@': 1158}), 33: (1, {'@': 1158}), 64: (1, {'@': 1158}), 66: (1, {'@': 1158}), 67: (1, {'@': 1158}), 34: (1, {'@': 1158}), 36: (1, {'@': 1158}), 37: (1, {'@': 1158}), 68: (1, {'@': 1158}), 38: (1, {'@': 1158}), 69: (1, {'@': 1158}), 70: (1, {'@': 1158}), 71: (1, {'@': 1158}), 40: (1, {'@': 1158}), 72: (1, {'@': 1158}), 41: (1, {'@': 1158}), 73: (1, {'@': 1158}), 74: (1, {'@': 1158}), 75: (1, {'@': 1158})}, 1042: {60: (0, 760)}, 1043: {288: (0, 1534), 289: (0, 1516), 290: (0, 1521), 8: (0, 1510), 291: (0, 1519), 52: (0, 1498), 292: (0, 1531), 293: (0, 1500), 146: (1, {'@': 376}), 60: (1, {'@': 739})}, 1044: {126: (0, 610), 60: (1, {'@': 1548}), 146: (1, {'@': 1548})}, 1045: {60: (0, 735)}, 1046: {60: (0, 523)}, 1047: {126: (0, 768), 146: (1, {'@': 1429})}, 1048: {58: (0, 1666), 172: (0, 1671), 53: (0, 387), 294: (0, 1675), 33: (0, 383), 44: (0, 358), 66: (0, 1679), 210: (0, 1680), 183: (0, 1685), 295: (0, 1688), 28: (0, 33), 165: (0, 1693), 204: (0, 1696), 296: (0, 1701), 37: (0, 1828), 297: (0, 1706), 6: (0, 20), 185: (0, 1710), 0: (1, {'@': 420}), 3: (1, {'@': 420}), 20: (1, {'@': 420}), 32: (1, {'@': 420}), 65: (1, {'@': 420}), 10: (1, {'@': 420}), 35: (1, {'@': 420}), 12: (1, {'@': 420}), 46: (1, {'@': 420}), 24: (1, {'@': 420}), 14: (1, {'@': 420}), 13: (1, {'@': 420}), 39: (1, {'@': 420}), 42: (1, {'@': 420}), 56: (1, {'@': 420}), 16: (1, {'@': 420}), 5: (1, {'@': 420}), 19: (1, {'@': 420}), 146: (1, {'@': 384}), 60: (1, {'@': 847})}, 1049: {60: (0, 762)}, 1050: {57: (1, {'@': 999}), 60: (1, {'@': 999}), 43: (1, {'@': 999}), 1: (1, {'@': 999}), 2: (1, {'@': 999}), 44: (1, {'@': 999}), 45: (1, {'@': 999}), 47: (1, {'@': 999}), 48: (1, {'@': 999}), 4: (1, {'@': 999}), 49: (1, {'@': 999}), 50: (1, {'@': 999}), 51: (1, {'@': 999}), 6: (1, {'@': 999}), 52: (1, {'@': 999}), 8: (1, {'@': 999}), 7: (1, {'@': 999}), 9: (1, {'@': 999}), 53: (1, {'@': 999}), 11: (1, {'@': 999}), 54: (1, {'@': 999}), 55: (1, {'@': 999}), 15: (1, {'@': 999}), 17: (1, {'@': 999}), 18: (1, {'@': 999}), 58: (1, {'@': 999}), 59: (1, {'@': 999}), 21: (1, {'@': 999}), 22: (1, {'@': 999}), 61: (1, {'@': 999}), 126: (1, {'@': 999}), 62: (1, {'@': 999}), 23: (1, {'@': 999}), 25: (1, {'@': 999}), 26: (1, {'@': 999}), 63: (1, {'@': 999}), 27: (1, {'@': 999}), 28: (1, {'@': 999}), 29: (1, {'@': 999}), 30: (1, {'@': 999}), 31: (1, {'@': 999}), 33: (1, {'@': 999}), 64: (1, {'@': 999}), 66: (1, {'@': 999}), 67: (1, {'@': 999}), 34: (1, {'@': 999}), 36: (1, {'@': 999}), 37: (1, {'@': 999}), 68: (1, {'@': 999}), 38: (1, {'@': 999}), 69: (1, {'@': 999}), 70: (1, {'@': 999}), 71: (1, {'@': 999}), 40: (1, {'@': 999}), 72: (1, {'@': 999}), 41: (1, {'@': 999}), 73: (1, {'@': 999}), 74: (1, {'@': 999}), 75: (1, {'@': 999})}, 1051: {146: (0, 764)}, 1052: {115: (0, 44), 77: (0, 17), 108: (0, 400), 620: (0, 763), 621: (0, 767), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 622: (0, 769), 110: (0, 799), 19: (0, 800), 13: (0, 802), 86: (0, 774), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1053: {146: (1, {'@': 1432}), 126: (1, {'@': 1432})}, 1054: {301: (0, 1723), 7: (0, 45), 185: (0, 1730), 183: (0, 1733), 28: (0, 33), 164: (0, 1736), 61: (0, 25), 37: (0, 1828), 180: (0, 1741), 302: (0, 1746), 6: (0, 20), 165: (0, 1750), 60: (1, {'@': 912}), 146: (1, {'@': 388})}, 1055: {146: (0, 790)}, 1056: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 86: (0, 1216), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1057: {146: (0, 772)}, 1058: {620: (0, 763), 622: (0, 2322)}, 1059: {60: (0, 729)}, 1060: {304: (0, 108), 305: (0, 306), 306: (0, 1770), 60: (1, {'@': 548}), 146: (1, {'@': 368})}, 1061: {60: (0, 603)}, 1062: {126: (0, 782), 146: (1, {'@': 1428})}, 1063: {107: (0, 2409), 112: (0, 2376), 81: (0, 2295), 80: (0, 2414), 194: (0, 1223), 97: (0, 2370), 428: (0, 1176), 89: (0, 2384)}, 1064: {538: (0, 613), 623: (0, 728), 525: (0, 731), 524: (0, 737), 539: (0, 739)}, 1065: {6: (1, {'@': 1663}), 60: (1, {'@': 1663}), 7: (1, {'@': 1663}), 61: (1, {'@': 1663}), 126: (1, {'@': 1663}), 28: (1, {'@': 1663}), 17: (1, {'@': 1663}), 57: (1, {'@': 1663})}, 1066: {6: (1, {'@': 1666}), 60: (1, {'@': 1666}), 7: (1, {'@': 1666}), 61: (1, {'@': 1666}), 126: (1, {'@': 1666}), 28: (1, {'@': 1666}), 17: (1, {'@': 1666}), 57: (1, {'@': 1666})}, 1067: {164: (0, 1776), 27: (0, 408), 183: (0, 1779), 26: (0, 1797), 167: (0, 1782), 38: (0, 1811), 28: (0, 33), 307: (0, 1784), 163: (0, 1786), 61: (0, 25), 308: (0, 1789), 1: (0, 1793), 185: (0, 1796), 45: (0, 1833), 169: (0, 1798), 168: (0, 1803), 6: (0, 20), 309: (0, 1808), 0: (1, {'@': 428}), 3: (1, {'@': 428}), 20: (1, {'@': 428}), 32: (1, {'@': 428}), 65: (1, {'@': 428}), 10: (1, {'@': 428}), 35: (1, {'@': 428}), 12: (1, {'@': 428}), 46: (1, {'@': 428}), 24: (1, {'@': 428}), 14: (1, {'@': 428}), 13: (1, {'@': 428}), 39: (1, {'@': 428}), 42: (1, {'@': 428}), 56: (1, {'@': 428}), 16: (1, {'@': 428}), 5: (1, {'@': 428}), 19: (1, {'@': 428}), 60: (1, {'@': 972}), 146: (1, {'@': 394})}, 1068: {184: (0, 784), 17: (0, 50), 183: (0, 22), 7: (0, 45), 185: (0, 19), 28: (0, 33), 6: (0, 20), 180: (0, 27), 61: (0, 25), 164: (0, 24), 182: (0, 23)}, 1069: {126: (1, {'@': 1681}), 146: (1, {'@': 1681})}, 1070: {60: (0, 621)}, 1071: {112: (0, 1689), 146: (1, {'@': 367})}, 1072: {60: (0, 1518)}, 1073: {146: (0, 742)}, 1074: {60: (0, 605)}, 1075: {60: (0, 1859)}, 1076: {470: (0, 1862), 471: (0, 1848), 387: (0, 1852), 624: (0, 1845), 388: (0, 1864), 625: (0, 1851), 626: (0, 1868), 60: (1, {'@': 1340}), 146: (1, {'@': 414})}, 1077: {60: (0, 608)}, 1078: {146: (0, 839)}, 1079: {60: (0, 851)}, 1080: {60: (0, 1098)}, 1081: {627: (0, 1490), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 439: (0, 1253), 86: (0, 1494), 46: (0, 781), 434: (0, 1214), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 436: (0, 1217), 96: (0, 789), 82: (0, 791), 98: (0, 793), 432: (0, 1242), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 562: (0, 1245), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 438: (0, 1230), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 563: (0, 1497), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 144: (0, 1502), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1082: {60: (0, 803)}, 1083: {22: (0, 389), 48: (0, 1843), 7: (0, 45), 390: (0, 1819), 177: (0, 1812), 49: (0, 335), 391: (0, 1837), 393: (0, 1831), 179: (0, 1835), 206: (0, 1935), 198: (0, 1940), 72: (0, 1882), 392: (0, 1945), 178: (0, 1950), 180: (0, 1955), 628: (0, 1958), 394: (0, 1961), 395: (0, 1966), 60: (1, {'@': 588}), 146: (1, {'@': 370})}, 1084: {146: (0, 843)}, 1085: {200: (0, 1840), 22: (0, 389), 48: (0, 1843), 53: (0, 387), 58: (0, 1666), 33: (0, 383), 183: (0, 1844), 7: (0, 45), 197: (0, 1847), 164: (0, 1850), 59: (0, 363), 208: (0, 1854), 396: (0, 1858), 75: (0, 341), 36: (0, 15), 49: (0, 335), 172: (0, 1861), 28: (0, 33), 212: (0, 1865), 180: (0, 1871), 34: (0, 1589), 61: (0, 25), 397: (0, 1875), 72: (0, 1882), 206: (0, 1884), 69: (0, 1760), 204: (0, 1887), 198: (0, 1891), 296: (0, 1896), 6: (0, 20), 31: (0, 1901), 9: (0, 1906), 392: (0, 1911), 629: (0, 1915), 185: (0, 1918), 395: (0, 1921), 398: (0, 1926), 287: (0, 1931), 0: (1, {'@': 435}), 3: (1, {'@': 435}), 20: (1, {'@': 435}), 32: (1, {'@': 435}), 65: (1, {'@': 435}), 10: (1, {'@': 435}), 35: (1, {'@': 435}), 12: (1, {'@': 435}), 46: (1, {'@': 435}), 24: (1, {'@': 435}), 14: (1, {'@': 435}), 13: (1, {'@': 435}), 39: (1, {'@': 435}), 42: (1, {'@': 435}), 56: (1, {'@': 435}), 16: (1, {'@': 435}), 5: (1, {'@': 435}), 19: (1, {'@': 435}), 60: (1, {'@': 1136}), 146: (1, {'@': 404})}, 1086: {60: (0, 632)}, 1087: {146: (0, 847)}, 1088: {60: (0, 625)}, 1089: {146: (1, {'@': 1472})}, 1090: {146: (0, 794)}, 1091: {60: (0, 2076)}, 1092: {126: (1, {'@': 1475}), 146: (1, {'@': 1475})}, 1093: {112: (0, 785)}, 1094: {22: (0, 389), 53: (0, 387), 7: (0, 45), 198: (0, 1827), 402: (0, 1969), 59: (0, 363), 206: (0, 1456), 49: (0, 335), 34: (0, 1589), 180: (0, 1460), 212: (0, 1466), 287: (0, 1471), 200: (0, 1474), 69: (0, 1760), 630: (0, 1478), 172: (0, 1481), 0: (1, {'@': 434}), 3: (1, {'@': 434}), 20: (1, {'@': 434}), 32: (1, {'@': 434}), 65: (1, {'@': 434}), 10: (1, {'@': 434}), 35: (1, {'@': 434}), 12: (1, {'@': 434}), 46: (1, {'@': 434}), 24: (1, {'@': 434}), 14: (1, {'@': 434}), 13: (1, {'@': 434}), 39: (1, {'@': 434}), 42: (1, {'@': 434}), 56: (1, {'@': 434}), 16: (1, {'@': 434}), 5: (1, {'@': 434}), 19: (1, {'@': 434}), 60: (1, {'@': 1124}), 146: (1, {'@': 403})}, 1095: {60: (0, 649)}, 1096: {126: (0, 801), 631: (0, 805), 146: (1, {'@': 1471})}, 1097: {474: (0, 671), 473: (0, 1177), 475: (0, 675), 472: (0, 2418)}, 1098: {57: (1, {'@': 1194}), 60: (1, {'@': 1194}), 43: (1, {'@': 1194}), 1: (1, {'@': 1194}), 2: (1, {'@': 1194}), 44: (1, {'@': 1194}), 45: (1, {'@': 1194}), 47: (1, {'@': 1194}), 48: (1, {'@': 1194}), 4: (1, {'@': 1194}), 49: (1, {'@': 1194}), 50: (1, {'@': 1194}), 51: (1, {'@': 1194}), 6: (1, {'@': 1194}), 52: (1, {'@': 1194}), 8: (1, {'@': 1194}), 7: (1, {'@': 1194}), 9: (1, {'@': 1194}), 53: (1, {'@': 1194}), 11: (1, {'@': 1194}), 54: (1, {'@': 1194}), 55: (1, {'@': 1194}), 15: (1, {'@': 1194}), 17: (1, {'@': 1194}), 18: (1, {'@': 1194}), 58: (1, {'@': 1194}), 59: (1, {'@': 1194}), 21: (1, {'@': 1194}), 22: (1, {'@': 1194}), 61: (1, {'@': 1194}), 126: (1, {'@': 1194}), 62: (1, {'@': 1194}), 23: (1, {'@': 1194}), 25: (1, {'@': 1194}), 26: (1, {'@': 1194}), 63: (1, {'@': 1194}), 27: (1, {'@': 1194}), 28: (1, {'@': 1194}), 29: (1, {'@': 1194}), 30: (1, {'@': 1194}), 31: (1, {'@': 1194}), 33: (1, {'@': 1194}), 64: (1, {'@': 1194}), 66: (1, {'@': 1194}), 67: (1, {'@': 1194}), 34: (1, {'@': 1194}), 36: (1, {'@': 1194}), 37: (1, {'@': 1194}), 68: (1, {'@': 1194}), 38: (1, {'@': 1194}), 69: (1, {'@': 1194}), 70: (1, {'@': 1194}), 71: (1, {'@': 1194}), 40: (1, {'@': 1194}), 72: (1, {'@': 1194}), 41: (1, {'@': 1194}), 73: (1, {'@': 1194}), 74: (1, {'@': 1194}), 75: (1, {'@': 1194})}, 1099: {60: (1, {'@': 1369}), 57: (1, {'@': 1369})}, 1100: {112: (0, 1010), 146: (1, {'@': 363})}, 1101: {126: (1, {'@': 1683}), 146: (1, {'@': 1683})}, 1102: {112: (0, 792)}, 1103: {60: (0, 2044)}, 1104: {60: (0, 798)}, 1105: {112: (0, 295), 146: (1, {'@': 362})}, 1106: {146: (1, {'@': 1476})}, 1107: {22: (0, 389), 206: (0, 1492), 287: (0, 1488), 7: (0, 45), 34: (0, 1589), 180: (0, 1600), 421: (0, 1603), 632: (0, 1611), 60: (1, {'@': 1248}), 146: (1, {'@': 410})}, 1108: {126: (1, {'@': 1473}), 146: (1, {'@': 1473})}, 1109: {126: (1, {'@': 1474}), 146: (1, {'@': 1474})}, 1110: {526: (0, 601), 59: (0, 363), 212: (0, 746)}, 1111: {126: (0, 1558), 60: (0, 1551)}, 1112: {60: (0, 827)}, 1113: {60: (0, 829)}, 1114: {0: (1, {'@': 426}), 3: (1, {'@': 426}), 20: (1, {'@': 426}), 32: (1, {'@': 426}), 65: (1, {'@': 426}), 10: (1, {'@': 426}), 35: (1, {'@': 426}), 12: (1, {'@': 426}), 46: (1, {'@': 426}), 24: (1, {'@': 426}), 14: (1, {'@': 426}), 13: (1, {'@': 426}), 39: (1, {'@': 426}), 42: (1, {'@': 426}), 56: (1, {'@': 426}), 16: (1, {'@': 426}), 5: (1, {'@': 426}), 19: (1, {'@': 426}), 60: (1, {'@': 934}), 146: (1, {'@': 392})}, 1115: {515: (1, {'@': 1628}), 517: (1, {'@': 1628}), 60: (1, {'@': 1628}), 126: (1, {'@': 1628}), 514: (1, {'@': 1628}), 57: (1, {'@': 1628})}, 1116: {146: (0, 841)}, 1117: {7: (0, 45), 633: (0, 1619), 27: (0, 408), 180: (0, 1621), 28: (0, 33), 169: (0, 1623), 61: (0, 25), 165: (0, 1626), 37: (0, 1828), 426: (0, 1628), 6: (0, 20), 185: (0, 1636), 183: (0, 1638), 164: (0, 1643), 0: (1, {'@': 424}), 3: (1, {'@': 424}), 20: (1, {'@': 424}), 32: (1, {'@': 424}), 65: (1, {'@': 424}), 10: (1, {'@': 424}), 35: (1, {'@': 424}), 12: (1, {'@': 424}), 46: (1, {'@': 424}), 24: (1, {'@': 424}), 14: (1, {'@': 424}), 13: (1, {'@': 424}), 39: (1, {'@': 424}), 42: (1, {'@': 424}), 56: (1, {'@': 424}), 16: (1, {'@': 424}), 5: (1, {'@': 424}), 19: (1, {'@': 424}), 60: (1, {'@': 922}), 146: (1, {'@': 389})}, 1118: {513: (0, 1992), 514: (0, 1981), 515: (0, 1993), 517: (0, 2030), 516: (0, 1999), 512: (0, 751), 519: (0, 2021), 126: (0, 759), 57: (1, {'@': 565}), 60: (1, {'@': 565})}, 1119: {112: (0, 808), 146: (1, {'@': 1594})}, 1120: {112: (0, 796), 146: (1, {'@': 1588})}, 1121: {112: (0, 2129), 146: (1, {'@': 1600})}, 1122: {112: (0, 806), 146: (1, {'@': 1598})}, 1123: {22: (0, 389), 53: (0, 387), 172: (0, 1648), 7: (0, 45), 200: (0, 1652), 634: (0, 1656), 59: (0, 363), 406: (0, 1660), 49: (0, 335), 198: (0, 1667), 34: (0, 1589), 69: (0, 1760), 212: (0, 1669), 206: (0, 1673), 287: (0, 1676), 180: (0, 1678), 60: (1, {'@': 1112}), 0: (1, {'@': 433}), 3: (1, {'@': 433}), 20: (1, {'@': 433}), 32: (1, {'@': 433}), 65: (1, {'@': 433}), 10: (1, {'@': 433}), 35: (1, {'@': 433}), 12: (1, {'@': 433}), 46: (1, {'@': 433}), 24: (1, {'@': 433}), 14: (1, {'@': 433}), 13: (1, {'@': 433}), 39: (1, {'@': 433}), 42: (1, {'@': 433}), 56: (1, {'@': 433}), 16: (1, {'@': 433}), 5: (1, {'@': 433}), 19: (1, {'@': 433}), 146: (1, {'@': 402})}, 1124: {512: (0, 754), 513: (0, 1992), 514: (0, 1981), 515: (0, 1993), 517: (0, 2030), 516: (0, 1999), 519: (0, 2021)}, 1125: {126: (1, {'@': 1376}), 60: (1, {'@': 1376})}, 1126: {126: (1, {'@': 1379}), 60: (1, {'@': 1379})}, 1127: {112: (0, 810), 146: (1, {'@': 1592})}, 1128: {126: (1, {'@': 1377}), 60: (1, {'@': 1377})}, 1129: {60: (1, {'@': 931}), 146: (1, {'@': 390})}, 1130: {112: (0, 813), 146: (1, {'@': 1584})}, 1131: {167: (0, 1614), 165: (0, 1681), 411: (0, 1686), 164: (0, 1694), 27: (0, 408), 51: (0, 1695), 26: (0, 1797), 163: (0, 1698), 38: (0, 1811), 61: (0, 25), 410: (0, 1703), 169: (0, 1708), 37: (0, 1828), 635: (0, 1713), 0: (1, {'@': 429}), 3: (1, {'@': 429}), 20: (1, {'@': 429}), 32: (1, {'@': 429}), 65: (1, {'@': 429}), 10: (1, {'@': 429}), 35: (1, {'@': 429}), 12: (1, {'@': 429}), 46: (1, {'@': 429}), 24: (1, {'@': 429}), 14: (1, {'@': 429}), 13: (1, {'@': 429}), 39: (1, {'@': 429}), 42: (1, {'@': 429}), 56: (1, {'@': 429}), 16: (1, {'@': 429}), 5: (1, {'@': 429}), 19: (1, {'@': 429}), 146: (1, {'@': 395}), 60: (1, {'@': 989})}, 1132: {126: (1, {'@': 1383}), 60: (1, {'@': 1383})}, 1133: {112: (0, 788), 146: (1, {'@': 1596})}, 1134: {126: (1, {'@': 1381}), 60: (1, {'@': 1381})}, 1135: {76: (0, 2146), 77: (0, 17), 78: (0, 1960), 80: (0, 2149), 79: (0, 1973), 12: (0, 396), 81: (0, 2295), 82: (0, 791), 83: (0, 809), 84: (0, 811), 85: (0, 816), 10: (0, 826), 87: (0, 842), 35: (0, 844), 88: (0, 848), 89: (0, 2384), 90: (0, 853), 91: (0, 863), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 56: (0, 783), 95: (0, 786), 96: (0, 789), 97: (0, 2370), 98: (0, 793), 19: (0, 800), 13: (0, 802), 32: (0, 807), 99: (0, 812), 100: (0, 817), 20: (0, 822), 102: (0, 823), 103: (0, 825), 105: (0, 830), 65: (0, 834), 106: (0, 838), 107: (0, 2409), 108: (0, 400), 109: (0, 390), 46: (0, 781), 110: (0, 799), 86: (0, 1480), 111: (0, 821), 14: (0, 399), 112: (0, 2376), 113: (0, 828), 114: (0, 832), 101: (0, 1484), 0: (0, 846), 42: (0, 858), 39: (0, 860), 115: (0, 44), 116: (0, 780), 5: (0, 787), 117: (0, 804), 24: (0, 814), 118: (0, 819), 119: (0, 836), 120: (0, 840), 121: (0, 2154), 122: (0, 850), 3: (0, 855), 123: (0, 856), 124: (0, 864)}, 1136: {112: (0, 815), 146: (1, {'@': 1590})}, 1137: {115: (0, 44), 77: (0, 17), 108: (0, 400), 219: (0, 1780), 12: (0, 1939), 109: (0, 1830), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 1957), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 5: (0, 787), 91: (0, 863), 96: (0, 789), 82: (0, 791), 98: (0, 793), 124: (0, 864), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 1965), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 86: (0, 1804), 146: (1, {'@': 416})}, 1138: {112: (0, 818), 146: (1, {'@': 1586})}, 1139: {112: (0, 1718), 146: (1, {'@': 413})}, 1140: {57: (1, {'@': 1434}), 60: (1, {'@': 1434}), 6: (1, {'@': 1434}), 7: (1, {'@': 1434}), 61: (1, {'@': 1434}), 126: (1, {'@': 1434}), 45: (1, {'@': 1434}), 37: (1, {'@': 1434}), 38: (1, {'@': 1434}), 47: (1, {'@': 1434}), 26: (1, {'@': 1434}), 27: (1, {'@': 1434}), 4: (1, {'@': 1434}), 28: (1, {'@': 1434}), 50: (1, {'@': 1434}), 53: (1, {'@': 1434}), 67: (1, {'@': 1434}), 29: (1, {'@': 1434}), 30: (1, {'@': 1434}), 15: (1, {'@': 1434}), 43: (1, {'@': 1434}), 21: (1, {'@': 1434}), 44: (1, {'@': 1434}), 33: (1, {'@': 1434}), 64: (1, {'@': 1434}), 34: (1, {'@': 1434}), 54: (1, {'@': 1434}), 69: (1, {'@': 1434}), 40: (1, {'@': 1434}), 74: (1, {'@': 1434}), 41: (1, {'@': 1434}), 75: (1, {'@': 1434}), 18: (1, {'@': 1434}), 58: (1, {'@': 1434}), 66: (1, {'@': 1434}), 2: (1, {'@': 1434}), 63: (1, {'@': 1434}), 52: (1, {'@': 1434}), 8: (1, {'@': 1434}), 71: (1, {'@': 1434}), 55: (1, {'@': 1434}), 1: (1, {'@': 1434}), 48: (1, {'@': 1434}), 49: (1, {'@': 1434}), 51: (1, {'@': 1434}), 9: (1, {'@': 1434}), 11: (1, {'@': 1434}), 17: (1, {'@': 1434}), 59: (1, {'@': 1434}), 22: (1, {'@': 1434}), 62: (1, {'@': 1434}), 23: (1, {'@': 1434}), 25: (1, {'@': 1434}), 31: (1, {'@': 1434}), 36: (1, {'@': 1434}), 68: (1, {'@': 1434}), 70: (1, {'@': 1434}), 72: (1, {'@': 1434}), 73: (1, {'@': 1434})}, 1141: {636: (0, 831), 126: (0, 833), 60: (1, {'@': 1375})}, 1142: {637: (0, 1772), 193: (0, 53), 638: (0, 1775), 192: (0, 1777), 146: (1, {'@': 377})}, 1143: {126: (1, {'@': 1694}), 146: (1, {'@': 1694})}, 1144: {126: (1, {'@': 1380}), 60: (1, {'@': 1380})}, 1145: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 1164)}, 1146: {146: (0, 824)}, 1147: {193: (0, 53), 453: (0, 1809), 192: (0, 1814), 452: (0, 1821), 639: (0, 1822), 146: (1, {'@': 379})}, 1148: {126: (0, 300)}, 1149: {60: (0, 820)}, 1150: {57: (1, {'@': 777}), 60: (1, {'@': 777}), 126: (1, {'@': 777}), 193: (1, {'@': 777})}, 1151: {60: (0, 657)}, 1152: {126: (1, {'@': 1378}), 60: (1, {'@': 1378})}, 1153: {146: (1, {'@': 1373})}, 1154: {107: (0, 2409), 112: (0, 2376), 81: (0, 2295), 80: (0, 2414), 194: (0, 1223), 97: (0, 2370), 428: (0, 1162), 89: (0, 2384)}, 1155: {60: (0, 1509)}, 1156: {126: (1, {'@': 1382}), 60: (1, {'@': 1382})}, 1157: {146: (1, {'@': 1349})}, 1158: {146: (0, 852)}, 1159: {185: (0, 311), 469: (0, 2282), 640: (0, 2284), 477: (0, 2288), 6: (0, 20), 478: (0, 2296), 60: (1, {'@': 1239}), 146: (1, {'@': 409})}, 1160: {60: (1, {'@': 684})}, 1161: {60: (0, 1487)}, 1162: {60: (0, 1506)}, 1163: {60: (0, 837)}, 1164: {60: (0, 1513)}, 1165: {60: (1, {'@': 1070}), 146: (1, {'@': 399})}, 1166: {60: (0, 445)}, 1167: {133: (1, {'@': 1649}), 130: (1, {'@': 1649}), 141: (1, {'@': 1649}), 60: (1, {'@': 1649}), 129: (1, {'@': 1649}), 126: (1, {'@': 1649}), 134: (1, {'@': 1649}), 57: (1, {'@': 1649}), 132: (1, {'@': 1649}), 139: (1, {'@': 1649})}, 1168: {146: (0, 722)}, 1169: {146: (1, {'@': 836})}, 1170: {11: (0, 84), 484: (0, 966), 0: (1, {'@': 422}), 3: (1, {'@': 422}), 20: (1, {'@': 422}), 32: (1, {'@': 422}), 65: (1, {'@': 422}), 10: (1, {'@': 422}), 35: (1, {'@': 422}), 12: (1, {'@': 422}), 46: (1, {'@': 422}), 24: (1, {'@': 422}), 14: (1, {'@': 422}), 13: (1, {'@': 422}), 39: (1, {'@': 422}), 42: (1, {'@': 422}), 56: (1, {'@': 422}), 16: (1, {'@': 422}), 5: (1, {'@': 422}), 19: (1, {'@': 422}), 60: (1, {'@': 897}), 146: (1, {'@': 386})}, 1171: {60: (0, 1535)}, 1172: {146: (0, 865)}, 1173: {146: (1, {'@': 835})}, 1174: {60: (0, 2403)}, 1175: {2: (1, {'@': 832}), 60: (1, {'@': 832}), 44: (1, {'@': 832}), 61: (1, {'@': 832}), 126: (1, {'@': 832}), 63: (1, {'@': 832}), 28: (1, {'@': 832}), 33: (1, {'@': 832}), 6: (1, {'@': 832}), 52: (1, {'@': 832}), 8: (1, {'@': 832}), 53: (1, {'@': 832}), 37: (1, {'@': 832}), 71: (1, {'@': 832}), 55: (1, {'@': 832}), 57: (1, {'@': 832}), 43: (1, {'@': 832}), 1: (1, {'@': 832}), 45: (1, {'@': 832}), 47: (1, {'@': 832}), 48: (1, {'@': 832}), 4: (1, {'@': 832}), 49: (1, {'@': 832}), 50: (1, {'@': 832}), 51: (1, {'@': 832}), 7: (1, {'@': 832}), 9: (1, {'@': 832}), 11: (1, {'@': 832}), 54: (1, {'@': 832}), 15: (1, {'@': 832}), 17: (1, {'@': 832}), 18: (1, {'@': 832}), 58: (1, {'@': 832}), 59: (1, {'@': 832}), 21: (1, {'@': 832}), 22: (1, {'@': 832}), 62: (1, {'@': 832}), 23: (1, {'@': 832}), 25: (1, {'@': 832}), 26: (1, {'@': 832}), 27: (1, {'@': 832}), 29: (1, {'@': 832}), 30: (1, {'@': 832}), 31: (1, {'@': 832}), 64: (1, {'@': 832}), 66: (1, {'@': 832}), 67: (1, {'@': 832}), 34: (1, {'@': 832}), 36: (1, {'@': 832}), 68: (1, {'@': 832}), 38: (1, {'@': 832}), 69: (1, {'@': 832}), 70: (1, {'@': 832}), 40: (1, {'@': 832}), 72: (1, {'@': 832}), 41: (1, {'@': 832}), 73: (1, {'@': 832}), 74: (1, {'@': 832}), 75: (1, {'@': 832})}, 1176: {60: (0, 1523)}, 1177: {60: (0, 1530)}, 1178: {60: (0, 630)}, 1179: {60: (0, 1527)}, 1180: {60: (0, 845)}, 1181: {133: (1, {'@': 1652}), 130: (1, {'@': 1652}), 141: (1, {'@': 1652}), 60: (1, {'@': 1652}), 129: (1, {'@': 1652}), 126: (1, {'@': 1652}), 134: (1, {'@': 1652}), 57: (1, {'@': 1652}), 132: (1, {'@': 1652}), 139: (1, {'@': 1652})}, 1182: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 86: (0, 1169), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1183: {112: (1, {'@': 1306}), 57: (1, {'@': 1306}), 60: (1, {'@': 1306}), 147: (1, {'@': 1306}), 126: (1, {'@': 1306}), 148: (1, {'@': 1306}), 149: (1, {'@': 1306}), 150: (1, {'@': 1306}), 151: (1, {'@': 1306}), 152: (1, {'@': 1306}), 153: (1, {'@': 1306}), 154: (1, {'@': 1306}), 155: (1, {'@': 1306}), 156: (1, {'@': 1306}), 157: (1, {'@': 1306}), 158: (1, {'@': 1306}), 159: (1, {'@': 1306}), 160: (1, {'@': 1306})}, 1184: {146: (0, 1544)}, 1185: {128: (0, 14), 129: (0, 12), 130: (0, 11), 131: (0, 10), 132: (0, 8), 133: (0, 4), 134: (0, 13), 136: (0, 9), 137: (0, 5), 138: (0, 6), 139: (0, 18), 141: (0, 49), 142: (0, 46), 140: (0, 866), 143: (0, 26)}, 1186: {60: (0, 1540)}, 1187: {641: (0, 626), 642: (0, 644), 643: (0, 1157)}, 1188: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 1155)}, 1189: {112: (1, {'@': 1309}), 57: (1, {'@': 1309}), 60: (1, {'@': 1309}), 147: (1, {'@': 1309}), 126: (1, {'@': 1309}), 148: (1, {'@': 1309}), 149: (1, {'@': 1309}), 150: (1, {'@': 1309}), 151: (1, {'@': 1309}), 152: (1, {'@': 1309}), 153: (1, {'@': 1309}), 154: (1, {'@': 1309}), 155: (1, {'@': 1309}), 156: (1, {'@': 1309}), 157: (1, {'@': 1309}), 158: (1, {'@': 1309}), 159: (1, {'@': 1309}), 160: (1, {'@': 1309})}, 1190: {146: (0, 861)}, 1191: {57: (1, {'@': 1357}), 60: (1, {'@': 1357}), 126: (1, {'@': 1357}), 387: (1, {'@': 1357})}, 1192: {144: (0, 1324), 560: (0, 1072)}, 1193: {112: (1, {'@': 1300}), 57: (1, {'@': 1300}), 60: (1, {'@': 1300}), 147: (1, {'@': 1300}), 126: (1, {'@': 1300}), 148: (1, {'@': 1300}), 149: (1, {'@': 1300}), 150: (1, {'@': 1300}), 151: (1, {'@': 1300}), 152: (1, {'@': 1300}), 153: (1, {'@': 1300}), 154: (1, {'@': 1300}), 155: (1, {'@': 1300}), 156: (1, {'@': 1300}), 157: (1, {'@': 1300}), 158: (1, {'@': 1300}), 159: (1, {'@': 1300}), 160: (1, {'@': 1300})}, 1194: {60: (0, 849)}, 1195: {2: (1, {'@': 844}), 60: (1, {'@': 844}), 44: (1, {'@': 844}), 61: (1, {'@': 844}), 126: (1, {'@': 844}), 63: (1, {'@': 844}), 28: (1, {'@': 844}), 33: (1, {'@': 844}), 6: (1, {'@': 844}), 52: (1, {'@': 844}), 8: (1, {'@': 844}), 53: (1, {'@': 844}), 37: (1, {'@': 844}), 71: (1, {'@': 844}), 55: (1, {'@': 844}), 57: (1, {'@': 844}), 43: (1, {'@': 844}), 1: (1, {'@': 844}), 45: (1, {'@': 844}), 47: (1, {'@': 844}), 48: (1, {'@': 844}), 4: (1, {'@': 844}), 49: (1, {'@': 844}), 50: (1, {'@': 844}), 51: (1, {'@': 844}), 7: (1, {'@': 844}), 9: (1, {'@': 844}), 11: (1, {'@': 844}), 54: (1, {'@': 844}), 15: (1, {'@': 844}), 17: (1, {'@': 844}), 18: (1, {'@': 844}), 58: (1, {'@': 844}), 59: (1, {'@': 844}), 21: (1, {'@': 844}), 22: (1, {'@': 844}), 62: (1, {'@': 844}), 23: (1, {'@': 844}), 25: (1, {'@': 844}), 26: (1, {'@': 844}), 27: (1, {'@': 844}), 29: (1, {'@': 844}), 30: (1, {'@': 844}), 31: (1, {'@': 844}), 64: (1, {'@': 844}), 66: (1, {'@': 844}), 67: (1, {'@': 844}), 34: (1, {'@': 844}), 36: (1, {'@': 844}), 68: (1, {'@': 844}), 38: (1, {'@': 844}), 69: (1, {'@': 844}), 70: (1, {'@': 844}), 40: (1, {'@': 844}), 72: (1, {'@': 844}), 41: (1, {'@': 844}), 73: (1, {'@': 844}), 74: (1, {'@': 844}), 75: (1, {'@': 844})}, 1196: {112: (1, {'@': 1312}), 57: (1, {'@': 1312}), 60: (1, {'@': 1312}), 147: (1, {'@': 1312}), 126: (1, {'@': 1312}), 148: (1, {'@': 1312}), 149: (1, {'@': 1312}), 150: (1, {'@': 1312}), 151: (1, {'@': 1312}), 152: (1, {'@': 1312}), 153: (1, {'@': 1312}), 154: (1, {'@': 1312}), 155: (1, {'@': 1312}), 156: (1, {'@': 1312}), 157: (1, {'@': 1312}), 158: (1, {'@': 1312}), 159: (1, {'@': 1312}), 160: (1, {'@': 1312})}, 1197: {60: (1, {'@': 534})}, 1198: {60: (1, {'@': 1679}), 21: (1, {'@': 1679}), 22: (1, {'@': 1679}), 44: (1, {'@': 1679}), 126: (1, {'@': 1679}), 62: (1, {'@': 1679}), 61: (1, {'@': 1679}), 28: (1, {'@': 1679}), 33: (1, {'@': 1679}), 6: (1, {'@': 1679}), 64: (1, {'@': 1679}), 34: (1, {'@': 1679}), 53: (1, {'@': 1679}), 54: (1, {'@': 1679}), 69: (1, {'@': 1679}), 40: (1, {'@': 1679}), 73: (1, {'@': 1679}), 75: (1, {'@': 1679}), 57: (1, {'@': 1679}), 18: (1, {'@': 1679})}, 1199: {112: (1, {'@': 1272}), 57: (1, {'@': 1272}), 60: (1, {'@': 1272}), 147: (1, {'@': 1272}), 126: (1, {'@': 1272}), 148: (1, {'@': 1272}), 149: (1, {'@': 1272}), 150: (1, {'@': 1272}), 151: (1, {'@': 1272}), 152: (1, {'@': 1272}), 153: (1, {'@': 1272}), 154: (1, {'@': 1272}), 155: (1, {'@': 1272}), 156: (1, {'@': 1272}), 157: (1, {'@': 1272}), 158: (1, {'@': 1272}), 159: (1, {'@': 1272}), 160: (1, {'@': 1272})}, 1200: {60: (1, {'@': 535})}, 1201: {2: (1, {'@': 839}), 60: (1, {'@': 839}), 44: (1, {'@': 839}), 61: (1, {'@': 839}), 126: (1, {'@': 839}), 63: (1, {'@': 839}), 28: (1, {'@': 839}), 33: (1, {'@': 839}), 6: (1, {'@': 839}), 52: (1, {'@': 839}), 8: (1, {'@': 839}), 53: (1, {'@': 839}), 37: (1, {'@': 839}), 71: (1, {'@': 839}), 55: (1, {'@': 839}), 57: (1, {'@': 839}), 43: (1, {'@': 839}), 1: (1, {'@': 839}), 45: (1, {'@': 839}), 47: (1, {'@': 839}), 48: (1, {'@': 839}), 4: (1, {'@': 839}), 49: (1, {'@': 839}), 50: (1, {'@': 839}), 51: (1, {'@': 839}), 7: (1, {'@': 839}), 9: (1, {'@': 839}), 11: (1, {'@': 839}), 54: (1, {'@': 839}), 15: (1, {'@': 839}), 17: (1, {'@': 839}), 18: (1, {'@': 839}), 58: (1, {'@': 839}), 59: (1, {'@': 839}), 21: (1, {'@': 839}), 22: (1, {'@': 839}), 62: (1, {'@': 839}), 23: (1, {'@': 839}), 25: (1, {'@': 839}), 26: (1, {'@': 839}), 27: (1, {'@': 839}), 29: (1, {'@': 839}), 30: (1, {'@': 839}), 31: (1, {'@': 839}), 64: (1, {'@': 839}), 66: (1, {'@': 839}), 67: (1, {'@': 839}), 34: (1, {'@': 839}), 36: (1, {'@': 839}), 68: (1, {'@': 839}), 38: (1, {'@': 839}), 69: (1, {'@': 839}), 70: (1, {'@': 839}), 40: (1, {'@': 839}), 72: (1, {'@': 839}), 41: (1, {'@': 839}), 73: (1, {'@': 839}), 74: (1, {'@': 839}), 75: (1, {'@': 839})}, 1202: {112: (1, {'@': 1303}), 57: (1, {'@': 1303}), 60: (1, {'@': 1303}), 147: (1, {'@': 1303}), 126: (1, {'@': 1303}), 148: (1, {'@': 1303}), 149: (1, {'@': 1303}), 150: (1, {'@': 1303}), 151: (1, {'@': 1303}), 152: (1, {'@': 1303}), 153: (1, {'@': 1303}), 154: (1, {'@': 1303}), 155: (1, {'@': 1303}), 156: (1, {'@': 1303}), 157: (1, {'@': 1303}), 158: (1, {'@': 1303}), 159: (1, {'@': 1303}), 160: (1, {'@': 1303})}, 1203: {60: (1, {'@': 536})}, 1204: {311: (0, 2072), 448: (0, 1173)}, 1205: {6: (1, {'@': 909}), 60: (1, {'@': 909}), 7: (1, {'@': 909}), 61: (1, {'@': 909}), 126: (1, {'@': 909}), 28: (1, {'@': 909}), 17: (1, {'@': 909}), 57: (1, {'@': 909}), 43: (1, {'@': 909}), 1: (1, {'@': 909}), 2: (1, {'@': 909}), 44: (1, {'@': 909}), 45: (1, {'@': 909}), 47: (1, {'@': 909}), 48: (1, {'@': 909}), 4: (1, {'@': 909}), 49: (1, {'@': 909}), 50: (1, {'@': 909}), 51: (1, {'@': 909}), 52: (1, {'@': 909}), 8: (1, {'@': 909}), 9: (1, {'@': 909}), 53: (1, {'@': 909}), 11: (1, {'@': 909}), 54: (1, {'@': 909}), 55: (1, {'@': 909}), 15: (1, {'@': 909}), 18: (1, {'@': 909}), 58: (1, {'@': 909}), 59: (1, {'@': 909}), 21: (1, {'@': 909}), 22: (1, {'@': 909}), 62: (1, {'@': 909}), 23: (1, {'@': 909}), 25: (1, {'@': 909}), 26: (1, {'@': 909}), 63: (1, {'@': 909}), 27: (1, {'@': 909}), 29: (1, {'@': 909}), 30: (1, {'@': 909}), 31: (1, {'@': 909}), 33: (1, {'@': 909}), 64: (1, {'@': 909}), 66: (1, {'@': 909}), 67: (1, {'@': 909}), 34: (1, {'@': 909}), 36: (1, {'@': 909}), 37: (1, {'@': 909}), 68: (1, {'@': 909}), 38: (1, {'@': 909}), 69: (1, {'@': 909}), 70: (1, {'@': 909}), 71: (1, {'@': 909}), 40: (1, {'@': 909}), 72: (1, {'@': 909}), 41: (1, {'@': 909}), 73: (1, {'@': 909}), 74: (1, {'@': 909}), 75: (1, {'@': 909})}, 1206: {60: (0, 882)}, 1207: {43: (1, {'@': 899}), 1: (1, {'@': 899}), 2: (1, {'@': 899}), 44: (1, {'@': 899}), 45: (1, {'@': 899}), 47: (1, {'@': 899}), 48: (1, {'@': 899}), 4: (1, {'@': 899}), 49: (1, {'@': 899}), 50: (1, {'@': 899}), 51: (1, {'@': 899}), 6: (1, {'@': 899}), 52: (1, {'@': 899}), 8: (1, {'@': 899}), 7: (1, {'@': 899}), 9: (1, {'@': 899}), 53: (1, {'@': 899}), 11: (1, {'@': 899}), 54: (1, {'@': 899}), 55: (1, {'@': 899}), 15: (1, {'@': 899}), 17: (1, {'@': 899}), 57: (1, {'@': 899}), 18: (1, {'@': 899}), 58: (1, {'@': 899}), 59: (1, {'@': 899}), 21: (1, {'@': 899}), 22: (1, {'@': 899}), 60: (1, {'@': 899}), 61: (1, {'@': 899}), 126: (1, {'@': 899}), 62: (1, {'@': 899}), 23: (1, {'@': 899}), 25: (1, {'@': 899}), 26: (1, {'@': 899}), 63: (1, {'@': 899}), 27: (1, {'@': 899}), 28: (1, {'@': 899}), 29: (1, {'@': 899}), 30: (1, {'@': 899}), 31: (1, {'@': 899}), 33: (1, {'@': 899}), 64: (1, {'@': 899}), 66: (1, {'@': 899}), 67: (1, {'@': 899}), 34: (1, {'@': 899}), 36: (1, {'@': 899}), 37: (1, {'@': 899}), 68: (1, {'@': 899}), 38: (1, {'@': 899}), 69: (1, {'@': 899}), 70: (1, {'@': 899}), 71: (1, {'@': 899}), 40: (1, {'@': 899}), 72: (1, {'@': 899}), 41: (1, {'@': 899}), 73: (1, {'@': 899}), 74: (1, {'@': 899}), 75: (1, {'@': 899})}, 1208: {6: (1, {'@': 1477}), 60: (1, {'@': 1477}), 7: (1, {'@': 1477}), 61: (1, {'@': 1477}), 126: (1, {'@': 1477}), 28: (1, {'@': 1477}), 17: (1, {'@': 1477}), 57: (1, {'@': 1477}), 59: (1, {'@': 1477}), 21: (1, {'@': 1477}), 22: (1, {'@': 1477}), 44: (1, {'@': 1477}), 62: (1, {'@': 1477}), 23: (1, {'@': 1477}), 25: (1, {'@': 1477}), 49: (1, {'@': 1477}), 33: (1, {'@': 1477}), 53: (1, {'@': 1477}), 69: (1, {'@': 1477}), 40: (1, {'@': 1477}), 41: (1, {'@': 1477}), 75: (1, {'@': 1477}), 73: (1, {'@': 1477}), 45: (1, {'@': 1477}), 37: (1, {'@': 1477}), 38: (1, {'@': 1477}), 47: (1, {'@': 1477}), 26: (1, {'@': 1477}), 27: (1, {'@': 1477}), 4: (1, {'@': 1477}), 50: (1, {'@': 1477}), 174: (1, {'@': 1477}), 175: (1, {'@': 1477}), 176: (1, {'@': 1477}), 177: (1, {'@': 1477}), 48: (1, {'@': 1477}), 72: (1, {'@': 1477}), 178: (1, {'@': 1477}), 179: (1, {'@': 1477}), 43: (1, {'@': 1477}), 1: (1, {'@': 1477}), 2: (1, {'@': 1477}), 51: (1, {'@': 1477}), 52: (1, {'@': 1477}), 8: (1, {'@': 1477}), 9: (1, {'@': 1477}), 11: (1, {'@': 1477}), 54: (1, {'@': 1477}), 55: (1, {'@': 1477}), 15: (1, {'@': 1477}), 18: (1, {'@': 1477}), 58: (1, {'@': 1477}), 63: (1, {'@': 1477}), 29: (1, {'@': 1477}), 30: (1, {'@': 1477}), 31: (1, {'@': 1477}), 64: (1, {'@': 1477}), 66: (1, {'@': 1477}), 67: (1, {'@': 1477}), 34: (1, {'@': 1477}), 36: (1, {'@': 1477}), 68: (1, {'@': 1477}), 70: (1, {'@': 1477}), 71: (1, {'@': 1477}), 74: (1, {'@': 1477})}, 1209: {6: (1, {'@': 1426}), 60: (1, {'@': 1426}), 7: (1, {'@': 1426}), 61: (1, {'@': 1426}), 126: (1, {'@': 1426}), 28: (1, {'@': 1426}), 17: (1, {'@': 1426}), 57: (1, {'@': 1426}), 59: (1, {'@': 1426}), 21: (1, {'@': 1426}), 22: (1, {'@': 1426}), 44: (1, {'@': 1426}), 62: (1, {'@': 1426}), 23: (1, {'@': 1426}), 25: (1, {'@': 1426}), 49: (1, {'@': 1426}), 33: (1, {'@': 1426}), 53: (1, {'@': 1426}), 69: (1, {'@': 1426}), 40: (1, {'@': 1426}), 41: (1, {'@': 1426}), 75: (1, {'@': 1426}), 73: (1, {'@': 1426}), 45: (1, {'@': 1426}), 37: (1, {'@': 1426}), 38: (1, {'@': 1426}), 47: (1, {'@': 1426}), 26: (1, {'@': 1426}), 27: (1, {'@': 1426}), 4: (1, {'@': 1426}), 50: (1, {'@': 1426}), 43: (1, {'@': 1426}), 64: (1, {'@': 1426}), 34: (1, {'@': 1426}), 54: (1, {'@': 1426}), 74: (1, {'@': 1426}), 18: (1, {'@': 1426}), 58: (1, {'@': 1426}), 66: (1, {'@': 1426}), 1: (1, {'@': 1426}), 2: (1, {'@': 1426}), 63: (1, {'@': 1426}), 52: (1, {'@': 1426}), 8: (1, {'@': 1426}), 71: (1, {'@': 1426}), 55: (1, {'@': 1426}), 48: (1, {'@': 1426}), 51: (1, {'@': 1426}), 9: (1, {'@': 1426}), 11: (1, {'@': 1426}), 15: (1, {'@': 1426}), 29: (1, {'@': 1426}), 30: (1, {'@': 1426}), 31: (1, {'@': 1426}), 67: (1, {'@': 1426}), 36: (1, {'@': 1426}), 68: (1, {'@': 1426}), 70: (1, {'@': 1426}), 72: (1, {'@': 1426})}, 1210: {146: (0, 859)}, 1211: {2: (1, {'@': 830}), 60: (1, {'@': 830}), 44: (1, {'@': 830}), 61: (1, {'@': 830}), 126: (1, {'@': 830}), 63: (1, {'@': 830}), 28: (1, {'@': 830}), 33: (1, {'@': 830}), 6: (1, {'@': 830}), 52: (1, {'@': 830}), 8: (1, {'@': 830}), 53: (1, {'@': 830}), 37: (1, {'@': 830}), 71: (1, {'@': 830}), 55: (1, {'@': 830}), 57: (1, {'@': 830}), 43: (1, {'@': 830}), 1: (1, {'@': 830}), 45: (1, {'@': 830}), 47: (1, {'@': 830}), 48: (1, {'@': 830}), 4: (1, {'@': 830}), 49: (1, {'@': 830}), 50: (1, {'@': 830}), 51: (1, {'@': 830}), 7: (1, {'@': 830}), 9: (1, {'@': 830}), 11: (1, {'@': 830}), 54: (1, {'@': 830}), 15: (1, {'@': 830}), 17: (1, {'@': 830}), 18: (1, {'@': 830}), 58: (1, {'@': 830}), 59: (1, {'@': 830}), 21: (1, {'@': 830}), 22: (1, {'@': 830}), 62: (1, {'@': 830}), 23: (1, {'@': 830}), 25: (1, {'@': 830}), 26: (1, {'@': 830}), 27: (1, {'@': 830}), 29: (1, {'@': 830}), 30: (1, {'@': 830}), 31: (1, {'@': 830}), 64: (1, {'@': 830}), 66: (1, {'@': 830}), 67: (1, {'@': 830}), 34: (1, {'@': 830}), 36: (1, {'@': 830}), 68: (1, {'@': 830}), 38: (1, {'@': 830}), 69: (1, {'@': 830}), 70: (1, {'@': 830}), 40: (1, {'@': 830}), 72: (1, {'@': 830}), 41: (1, {'@': 830}), 73: (1, {'@': 830}), 74: (1, {'@': 830}), 75: (1, {'@': 830})}, 1212: {57: (1, {'@': 1422}), 60: (1, {'@': 1422}), 6: (1, {'@': 1422}), 7: (1, {'@': 1422}), 61: (1, {'@': 1422}), 126: (1, {'@': 1422}), 28: (1, {'@': 1422}), 17: (1, {'@': 1422}), 59: (1, {'@': 1422}), 21: (1, {'@': 1422}), 22: (1, {'@': 1422}), 44: (1, {'@': 1422}), 62: (1, {'@': 1422}), 23: (1, {'@': 1422}), 25: (1, {'@': 1422}), 49: (1, {'@': 1422}), 33: (1, {'@': 1422}), 53: (1, {'@': 1422}), 69: (1, {'@': 1422}), 40: (1, {'@': 1422}), 41: (1, {'@': 1422}), 75: (1, {'@': 1422}), 73: (1, {'@': 1422}), 45: (1, {'@': 1422}), 37: (1, {'@': 1422}), 38: (1, {'@': 1422}), 47: (1, {'@': 1422}), 26: (1, {'@': 1422}), 27: (1, {'@': 1422}), 4: (1, {'@': 1422}), 50: (1, {'@': 1422}), 67: (1, {'@': 1422}), 29: (1, {'@': 1422}), 30: (1, {'@': 1422}), 15: (1, {'@': 1422}), 43: (1, {'@': 1422}), 64: (1, {'@': 1422}), 34: (1, {'@': 1422}), 54: (1, {'@': 1422}), 74: (1, {'@': 1422}), 18: (1, {'@': 1422}), 1: (1, {'@': 1422}), 2: (1, {'@': 1422}), 63: (1, {'@': 1422}), 52: (1, {'@': 1422}), 8: (1, {'@': 1422}), 71: (1, {'@': 1422}), 55: (1, {'@': 1422}), 48: (1, {'@': 1422}), 51: (1, {'@': 1422}), 9: (1, {'@': 1422}), 11: (1, {'@': 1422}), 58: (1, {'@': 1422}), 31: (1, {'@': 1422}), 66: (1, {'@': 1422}), 36: (1, {'@': 1422}), 68: (1, {'@': 1422}), 70: (1, {'@': 1422}), 72: (1, {'@': 1422})}, 1213: {80: (0, 2414), 194: (0, 1179), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 1214: {126: (1, {'@': 1395}), 146: (1, {'@': 1395})}, 1215: {6: (1, {'@': 1468}), 60: (1, {'@': 1468}), 7: (1, {'@': 1468}), 61: (1, {'@': 1468}), 126: (1, {'@': 1468}), 28: (1, {'@': 1468}), 17: (1, {'@': 1468}), 57: (1, {'@': 1468}), 59: (1, {'@': 1468}), 21: (1, {'@': 1468}), 22: (1, {'@': 1468}), 44: (1, {'@': 1468}), 62: (1, {'@': 1468}), 23: (1, {'@': 1468}), 25: (1, {'@': 1468}), 49: (1, {'@': 1468}), 33: (1, {'@': 1468}), 53: (1, {'@': 1468}), 69: (1, {'@': 1468}), 40: (1, {'@': 1468}), 41: (1, {'@': 1468}), 75: (1, {'@': 1468}), 73: (1, {'@': 1468}), 45: (1, {'@': 1468}), 37: (1, {'@': 1468}), 38: (1, {'@': 1468}), 47: (1, {'@': 1468}), 26: (1, {'@': 1468}), 27: (1, {'@': 1468}), 4: (1, {'@': 1468}), 50: (1, {'@': 1468}), 43: (1, {'@': 1468}), 64: (1, {'@': 1468}), 34: (1, {'@': 1468}), 54: (1, {'@': 1468}), 74: (1, {'@': 1468}), 18: (1, {'@': 1468}), 58: (1, {'@': 1468}), 66: (1, {'@': 1468}), 1: (1, {'@': 1468}), 2: (1, {'@': 1468}), 63: (1, {'@': 1468}), 52: (1, {'@': 1468}), 8: (1, {'@': 1468}), 71: (1, {'@': 1468}), 55: (1, {'@': 1468}), 48: (1, {'@': 1468}), 51: (1, {'@': 1468}), 9: (1, {'@': 1468}), 11: (1, {'@': 1468}), 15: (1, {'@': 1468}), 29: (1, {'@': 1468}), 30: (1, {'@': 1468}), 31: (1, {'@': 1468}), 67: (1, {'@': 1468}), 36: (1, {'@': 1468}), 68: (1, {'@': 1468}), 70: (1, {'@': 1468}), 72: (1, {'@': 1468}), 469: (1, {'@': 1468})}, 1216: {146: (1, {'@': 1350})}, 1217: {126: (1, {'@': 1393}), 146: (1, {'@': 1393})}, 1218: {126: (1, {'@': 1573}), 146: (1, {'@': 1573})}, 1219: {126: (1, {'@': 1389}), 146: (1, {'@': 1389})}, 1220: {126: (1, {'@': 1698}), 146: (1, {'@': 1698})}, 1221: {112: (0, 873)}, 1222: {126: (1, {'@': 1574}), 146: (1, {'@': 1574})}, 1223: {644: (0, 862), 126: (0, 871), 60: (1, {'@': 1547})}, 1224: {454: (0, 188), 455: (0, 210), 456: (0, 212), 457: (0, 213), 458: (0, 215), 459: (0, 216), 461: (0, 219), 460: (0, 1184), 144: (0, 221), 462: (0, 223), 463: (0, 224)}, 1225: {146: (1, {'@': 1593})}, 1226: {60: (0, 138)}, 1227: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 1186)}, 1228: {146: (1, {'@': 1587})}, 1229: {126: (1, {'@': 1691}), 60: (1, {'@': 1691})}, 1230: {126: (1, {'@': 1396}), 146: (1, {'@': 1396})}, 1231: {146: (1, {'@': 1599})}, 1232: {146: (0, 2468)}, 1233: {60: (0, 1199)}, 1234: {146: (1, {'@': 1597})}, 1235: {126: (0, 884), 645: (0, 888), 146: (1, {'@': 1387})}, 1236: {146: (1, {'@': 1591})}, 1237: {268: (1, {'@': 644}), 60: (1, {'@': 644}), 126: (1, {'@': 644}), 67: (1, {'@': 644}), 270: (1, {'@': 644}), 4: (1, {'@': 644}), 266: (1, {'@': 644}), 30: (1, {'@': 644}), 57: (1, {'@': 644})}, 1238: {144: (0, 2316), 145: (0, 1171)}, 1239: {146: (1, {'@': 1583})}, 1240: {60: (0, 877)}, 1241: {33: (1, {'@': 1661}), 2: (1, {'@': 1661}), 6: (1, {'@': 1661}), 52: (1, {'@': 1661}), 8: (1, {'@': 1661}), 44: (1, {'@': 1661}), 61: (1, {'@': 1661}), 53: (1, {'@': 1661}), 126: (1, {'@': 1661}), 60: (1, {'@': 1661}), 37: (1, {'@': 1661}), 71: (1, {'@': 1661}), 63: (1, {'@': 1661}), 55: (1, {'@': 1661}), 28: (1, {'@': 1661}), 57: (1, {'@': 1661})}, 1242: {126: (1, {'@': 1392}), 146: (1, {'@': 1392})}, 1243: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 1319)}, 1244: {146: (1, {'@': 1595})}, 1245: {126: (1, {'@': 1391}), 146: (1, {'@': 1391})}, 1246: {60: (1, {'@': 1730}), 126: (1, {'@': 1730}), 146: (1, {'@': 1730})}, 1247: {146: (1, {'@': 1589})}, 1248: {60: (1, {'@': 1219}), 7: (1, {'@': 1219}), 22: (1, {'@': 1219}), 126: (1, {'@': 1219}), 174: (1, {'@': 1219}), 175: (1, {'@': 1219}), 49: (1, {'@': 1219}), 57: (1, {'@': 1219}), 176: (1, {'@': 1219})}, 1249: {126: (1, {'@': 1388}), 146: (1, {'@': 1388})}, 1250: {60: (0, 1205)}, 1251: {146: (1, {'@': 1585})}, 1252: {60: (0, 1183)}, 1253: {126: (1, {'@': 1394}), 146: (1, {'@': 1394})}, 1254: {60: (0, 1189)}, 1255: {126: (1, {'@': 1692}), 60: (1, {'@': 1692})}, 1256: {60: (0, 1193)}, 1257: {126: (1, {'@': 1390}), 146: (1, {'@': 1390})}, 1258: {60: (0, 1196)}, 1259: {57: (1, {'@': 1371}), 60: (1, {'@': 1371}), 126: (1, {'@': 1371}), 263: (1, {'@': 1371}), 260: (1, {'@': 1371}), 299: (1, {'@': 1371}), 452: (1, {'@': 1371}), 400: (1, {'@': 1371})}, 1260: {146: (1, {'@': 1431})}, 1261: {146: (0, 892), 60: (0, 896)}, 1262: {60: (0, 1209)}, 1263: {133: (1, {'@': 691}), 130: (1, {'@': 691}), 141: (1, {'@': 691}), 60: (1, {'@': 691}), 129: (1, {'@': 691}), 126: (1, {'@': 691}), 134: (1, {'@': 691}), 57: (1, {'@': 691}), 132: (1, {'@': 691}), 139: (1, {'@': 691})}, 1264: {60: (0, 1202)}, 1265: {60: (0, 875), 146: (0, 897)}, 1266: {146: (1, {'@': 1430})}, 1267: {133: (1, {'@': 700}), 130: (1, {'@': 700}), 141: (1, {'@': 700}), 60: (1, {'@': 700}), 129: (1, {'@': 700}), 126: (1, {'@': 700}), 134: (1, {'@': 700}), 57: (1, {'@': 700}), 132: (1, {'@': 700}), 139: (1, {'@': 700})}, 1268: {60: (0, 1208)}, 1269: {146: (0, 890), 60: (0, 904)}, 1270: {60: (0, 1212)}, 1271: {133: (1, {'@': 697}), 130: (1, {'@': 697}), 141: (1, {'@': 697}), 60: (1, {'@': 697}), 129: (1, {'@': 697}), 126: (1, {'@': 697}), 134: (1, {'@': 697}), 57: (1, {'@': 697}), 132: (1, {'@': 697}), 139: (1, {'@': 697})}, 1272: {60: (0, 1215)}, 1273: {146: (0, 886), 60: (0, 908)}, 1274: {115: (0, 44), 77: (0, 17), 108: (0, 400), 546: (0, 1220), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 86: (0, 1092), 96: (0, 789), 547: (0, 1102), 82: (0, 791), 98: (0, 793), 110: (0, 799), 548: (0, 1108), 19: (0, 800), 13: (0, 802), 117: (0, 804), 549: (0, 1093), 83: (0, 809), 32: (0, 807), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 550: (0, 1109), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1275: {133: (1, {'@': 694}), 130: (1, {'@': 694}), 141: (1, {'@': 694}), 60: (1, {'@': 694}), 129: (1, {'@': 694}), 126: (1, {'@': 694}), 134: (1, {'@': 694}), 57: (1, {'@': 694}), 132: (1, {'@': 694}), 139: (1, {'@': 694})}, 1276: {60: (0, 902)}, 1277: {126: (1, {'@': 1697}), 146: (1, {'@': 1697})}, 1278: {133: (1, {'@': 682}), 130: (1, {'@': 682}), 141: (1, {'@': 682}), 60: (1, {'@': 682}), 129: (1, {'@': 682}), 126: (1, {'@': 682}), 134: (1, {'@': 682}), 57: (1, {'@': 682}), 132: (1, {'@': 682}), 139: (1, {'@': 682})}, 1279: {126: (0, 2265), 146: (1, {'@': 1491})}, 1280: {60: (0, 1218)}, 1281: {133: (1, {'@': 688}), 130: (1, {'@': 688}), 141: (1, {'@': 688}), 60: (1, {'@': 688}), 129: (1, {'@': 688}), 126: (1, {'@': 688}), 134: (1, {'@': 688}), 57: (1, {'@': 688}), 132: (1, {'@': 688}), 139: (1, {'@': 688})}, 1282: {60: (0, 937)}, 1283: {60: (0, 899)}, 1284: {90: (0, 1128), 106: (0, 1144), 114: (0, 1132), 96: (0, 1152), 552: (0, 1126), 103: (0, 1125), 87: (0, 1134), 82: (0, 1156), 551: (0, 1255)}, 1285: {133: (1, {'@': 703}), 130: (1, {'@': 703}), 141: (1, {'@': 703}), 60: (1, {'@': 703}), 129: (1, {'@': 703}), 126: (1, {'@': 703}), 134: (1, {'@': 703}), 57: (1, {'@': 703}), 132: (1, {'@': 703}), 139: (1, {'@': 703})}, 1286: {60: (0, 941)}, 1287: {60: (0, 1278)}, 1288: {60: (0, 1222)}, 1289: {57: (1, {'@': 532}), 60: (1, {'@': 532}), 126: (1, {'@': 532}), 222: (1, {'@': 532}), 220: (1, {'@': 532}), 36: (1, {'@': 532}), 221: (1, {'@': 532}), 223: (1, {'@': 532}), 43: (1, {'@': 532}), 1: (1, {'@': 532}), 2: (1, {'@': 532}), 44: (1, {'@': 532}), 45: (1, {'@': 532}), 47: (1, {'@': 532}), 48: (1, {'@': 532}), 4: (1, {'@': 532}), 49: (1, {'@': 532}), 50: (1, {'@': 532}), 51: (1, {'@': 532}), 6: (1, {'@': 532}), 52: (1, {'@': 532}), 8: (1, {'@': 532}), 7: (1, {'@': 532}), 9: (1, {'@': 532}), 53: (1, {'@': 532}), 11: (1, {'@': 532}), 54: (1, {'@': 532}), 55: (1, {'@': 532}), 15: (1, {'@': 532}), 17: (1, {'@': 532}), 18: (1, {'@': 532}), 58: (1, {'@': 532}), 59: (1, {'@': 532}), 21: (1, {'@': 532}), 22: (1, {'@': 532}), 61: (1, {'@': 532}), 62: (1, {'@': 532}), 23: (1, {'@': 532}), 25: (1, {'@': 532}), 26: (1, {'@': 532}), 63: (1, {'@': 532}), 27: (1, {'@': 532}), 28: (1, {'@': 532}), 29: (1, {'@': 532}), 30: (1, {'@': 532}), 31: (1, {'@': 532}), 33: (1, {'@': 532}), 64: (1, {'@': 532}), 66: (1, {'@': 532}), 67: (1, {'@': 532}), 34: (1, {'@': 532}), 37: (1, {'@': 532}), 68: (1, {'@': 532}), 38: (1, {'@': 532}), 69: (1, {'@': 532}), 70: (1, {'@': 532}), 71: (1, {'@': 532}), 40: (1, {'@': 532}), 72: (1, {'@': 532}), 41: (1, {'@': 532}), 73: (1, {'@': 532}), 74: (1, {'@': 532}), 75: (1, {'@': 532})}, 1290: {146: (0, 909)}, 1291: {60: (0, 1225)}, 1292: {144: (0, 1324), 560: (0, 1567)}, 1293: {126: (0, 920), 146: (1, {'@': 1490})}, 1294: {60: (0, 1228)}, 1295: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 194: (0, 1562), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 1296: {146: (0, 880)}, 1297: {60: (0, 1231)}, 1298: {146: (0, 913)}, 1299: {60: (0, 1234)}, 1300: {126: (1, {'@': 1631}), 60: (1, {'@': 1631})}, 1301: {646: (0, 931), 126: (0, 932)}, 1302: {60: (0, 1236)}, 1303: {60: (0, 1239)}, 1304: {57: (1, {'@': 1085}), 60: (1, {'@': 1085})}, 1305: {60: (0, 1244)}, 1306: {146: (1, {'@': 573})}, 1307: {60: (0, 1247)}, 1308: {60: (0, 1251)}, 1309: {146: (0, 915)}, 1310: {60: (0, 1259)}, 1311: {76: (0, 2146), 107: (0, 2409), 112: (0, 2376), 81: (0, 2295), 80: (0, 2149), 97: (0, 2370), 89: (0, 2384), 101: (0, 2256), 121: (0, 2154)}, 1312: {60: (0, 1289)}, 1313: {60: (0, 918)}, 1314: {126: (1, {'@': 1569}), 146: (1, {'@': 1569})}, 1315: {60: (0, 967)}, 1316: {60: (0, 1263)}, 1317: {57: (1, {'@': 1424}), 60: (1, {'@': 1424}), 59: (1, {'@': 1424}), 21: (1, {'@': 1424}), 22: (1, {'@': 1424}), 44: (1, {'@': 1424}), 126: (1, {'@': 1424}), 62: (1, {'@': 1424}), 61: (1, {'@': 1424}), 23: (1, {'@': 1424}), 25: (1, {'@': 1424}), 28: (1, {'@': 1424}), 49: (1, {'@': 1424}), 6: (1, {'@': 1424}), 33: (1, {'@': 1424}), 7: (1, {'@': 1424}), 53: (1, {'@': 1424}), 69: (1, {'@': 1424}), 40: (1, {'@': 1424}), 41: (1, {'@': 1424}), 75: (1, {'@': 1424}), 73: (1, {'@': 1424}), 67: (1, {'@': 1424}), 37: (1, {'@': 1424}), 45: (1, {'@': 1424}), 38: (1, {'@': 1424}), 26: (1, {'@': 1424}), 27: (1, {'@': 1424}), 4: (1, {'@': 1424}), 29: (1, {'@': 1424}), 30: (1, {'@': 1424}), 15: (1, {'@': 1424}), 125: (1, {'@': 1424}), 127: (1, {'@': 1424}), 43: (1, {'@': 1424}), 64: (1, {'@': 1424}), 34: (1, {'@': 1424}), 54: (1, {'@': 1424}), 74: (1, {'@': 1424}), 18: (1, {'@': 1424}), 58: (1, {'@': 1424}), 66: (1, {'@': 1424}), 2: (1, {'@': 1424}), 63: (1, {'@': 1424}), 52: (1, {'@': 1424}), 8: (1, {'@': 1424}), 71: (1, {'@': 1424}), 55: (1, {'@': 1424}), 1: (1, {'@': 1424}), 47: (1, {'@': 1424}), 48: (1, {'@': 1424}), 50: (1, {'@': 1424}), 51: (1, {'@': 1424}), 9: (1, {'@': 1424}), 11: (1, {'@': 1424}), 17: (1, {'@': 1424}), 31: (1, {'@': 1424}), 36: (1, {'@': 1424}), 68: (1, {'@': 1424}), 70: (1, {'@': 1424}), 72: (1, {'@': 1424})}, 1318: {60: (0, 1267)}, 1319: {126: (1, {'@': 1732}), 60: (1, {'@': 1732})}, 1320: {146: (0, 957)}, 1321: {60: (0, 1271)}, 1322: {60: (0, 1275)}, 1323: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 86: (0, 378), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1324: {647: (0, 1295)}, 1325: {60: (0, 1281)}, 1326: {60: (0, 1285)}, 1327: {648: (0, 1111), 126: (0, 1292), 60: (0, 1314)}, 1328: {80: (0, 2414), 194: (0, 773), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 1329: {107: (0, 2409), 112: (0, 2376), 81: (0, 2295), 428: (0, 1930), 80: (0, 2414), 194: (0, 1223), 97: (0, 2370), 89: (0, 2384)}, 1330: {126: (1, {'@': 1523})}, 1331: {59: (1, {'@': 1411}), 60: (1, {'@': 1411}), 21: (1, {'@': 1411}), 22: (1, {'@': 1411}), 44: (1, {'@': 1411}), 126: (1, {'@': 1411}), 62: (1, {'@': 1411}), 61: (1, {'@': 1411}), 23: (1, {'@': 1411}), 25: (1, {'@': 1411}), 28: (1, {'@': 1411}), 49: (1, {'@': 1411}), 6: (1, {'@': 1411}), 33: (1, {'@': 1411}), 7: (1, {'@': 1411}), 53: (1, {'@': 1411}), 69: (1, {'@': 1411}), 40: (1, {'@': 1411}), 41: (1, {'@': 1411}), 75: (1, {'@': 1411}), 73: (1, {'@': 1411}), 57: (1, {'@': 1411}), 43: (1, {'@': 1411}), 45: (1, {'@': 1411}), 27: (1, {'@': 1411}), 64: (1, {'@': 1411}), 34: (1, {'@': 1411}), 37: (1, {'@': 1411}), 54: (1, {'@': 1411}), 38: (1, {'@': 1411}), 74: (1, {'@': 1411}), 18: (1, {'@': 1411}), 58: (1, {'@': 1411}), 66: (1, {'@': 1411}), 2: (1, {'@': 1411}), 63: (1, {'@': 1411}), 52: (1, {'@': 1411}), 8: (1, {'@': 1411}), 71: (1, {'@': 1411}), 55: (1, {'@': 1411}), 1: (1, {'@': 1411}), 47: (1, {'@': 1411}), 48: (1, {'@': 1411}), 4: (1, {'@': 1411}), 50: (1, {'@': 1411}), 51: (1, {'@': 1411}), 9: (1, {'@': 1411}), 11: (1, {'@': 1411}), 15: (1, {'@': 1411}), 17: (1, {'@': 1411}), 26: (1, {'@': 1411}), 29: (1, {'@': 1411}), 30: (1, {'@': 1411}), 31: (1, {'@': 1411}), 67: (1, {'@': 1411}), 36: (1, {'@': 1411}), 68: (1, {'@': 1411}), 70: (1, {'@': 1411}), 72: (1, {'@': 1411})}, 1332: {126: (1, {'@': 1525})}, 1333: {59: (1, {'@': 1405}), 60: (1, {'@': 1405}), 21: (1, {'@': 1405}), 22: (1, {'@': 1405}), 44: (1, {'@': 1405}), 126: (1, {'@': 1405}), 62: (1, {'@': 1405}), 61: (1, {'@': 1405}), 23: (1, {'@': 1405}), 25: (1, {'@': 1405}), 28: (1, {'@': 1405}), 49: (1, {'@': 1405}), 6: (1, {'@': 1405}), 33: (1, {'@': 1405}), 7: (1, {'@': 1405}), 53: (1, {'@': 1405}), 69: (1, {'@': 1405}), 40: (1, {'@': 1405}), 41: (1, {'@': 1405}), 75: (1, {'@': 1405}), 73: (1, {'@': 1405}), 57: (1, {'@': 1405}), 43: (1, {'@': 1405}), 45: (1, {'@': 1405}), 27: (1, {'@': 1405}), 64: (1, {'@': 1405}), 34: (1, {'@': 1405}), 37: (1, {'@': 1405}), 54: (1, {'@': 1405}), 38: (1, {'@': 1405}), 74: (1, {'@': 1405}), 18: (1, {'@': 1405}), 58: (1, {'@': 1405}), 66: (1, {'@': 1405}), 2: (1, {'@': 1405}), 63: (1, {'@': 1405}), 52: (1, {'@': 1405}), 8: (1, {'@': 1405}), 71: (1, {'@': 1405}), 55: (1, {'@': 1405}), 1: (1, {'@': 1405}), 47: (1, {'@': 1405}), 48: (1, {'@': 1405}), 4: (1, {'@': 1405}), 50: (1, {'@': 1405}), 51: (1, {'@': 1405}), 9: (1, {'@': 1405}), 11: (1, {'@': 1405}), 15: (1, {'@': 1405}), 17: (1, {'@': 1405}), 26: (1, {'@': 1405}), 29: (1, {'@': 1405}), 30: (1, {'@': 1405}), 31: (1, {'@': 1405}), 67: (1, {'@': 1405}), 36: (1, {'@': 1405}), 68: (1, {'@': 1405}), 70: (1, {'@': 1405}), 72: (1, {'@': 1405})}, 1334: {126: (1, {'@': 1532})}, 1335: {126: (1, {'@': 1693}), 146: (1, {'@': 1693})}, 1336: {59: (1, {'@': 1407}), 60: (1, {'@': 1407}), 21: (1, {'@': 1407}), 22: (1, {'@': 1407}), 44: (1, {'@': 1407}), 126: (1, {'@': 1407}), 62: (1, {'@': 1407}), 61: (1, {'@': 1407}), 23: (1, {'@': 1407}), 25: (1, {'@': 1407}), 28: (1, {'@': 1407}), 49: (1, {'@': 1407}), 6: (1, {'@': 1407}), 33: (1, {'@': 1407}), 7: (1, {'@': 1407}), 53: (1, {'@': 1407}), 69: (1, {'@': 1407}), 40: (1, {'@': 1407}), 41: (1, {'@': 1407}), 75: (1, {'@': 1407}), 73: (1, {'@': 1407}), 57: (1, {'@': 1407}), 43: (1, {'@': 1407}), 45: (1, {'@': 1407}), 27: (1, {'@': 1407}), 64: (1, {'@': 1407}), 34: (1, {'@': 1407}), 37: (1, {'@': 1407}), 54: (1, {'@': 1407}), 38: (1, {'@': 1407}), 74: (1, {'@': 1407}), 18: (1, {'@': 1407}), 58: (1, {'@': 1407}), 66: (1, {'@': 1407}), 2: (1, {'@': 1407}), 63: (1, {'@': 1407}), 52: (1, {'@': 1407}), 8: (1, {'@': 1407}), 71: (1, {'@': 1407}), 55: (1, {'@': 1407}), 1: (1, {'@': 1407}), 47: (1, {'@': 1407}), 48: (1, {'@': 1407}), 4: (1, {'@': 1407}), 50: (1, {'@': 1407}), 51: (1, {'@': 1407}), 9: (1, {'@': 1407}), 11: (1, {'@': 1407}), 15: (1, {'@': 1407}), 17: (1, {'@': 1407}), 26: (1, {'@': 1407}), 29: (1, {'@': 1407}), 30: (1, {'@': 1407}), 31: (1, {'@': 1407}), 67: (1, {'@': 1407}), 36: (1, {'@': 1407}), 68: (1, {'@': 1407}), 70: (1, {'@': 1407}), 72: (1, {'@': 1407})}, 1337: {126: (1, {'@': 1535})}, 1338: {126: (1, {'@': 1731}), 60: (1, {'@': 1731})}, 1339: {59: (1, {'@': 1457}), 60: (1, {'@': 1457}), 21: (1, {'@': 1457}), 22: (1, {'@': 1457}), 44: (1, {'@': 1457}), 126: (1, {'@': 1457}), 62: (1, {'@': 1457}), 61: (1, {'@': 1457}), 23: (1, {'@': 1457}), 25: (1, {'@': 1457}), 28: (1, {'@': 1457}), 49: (1, {'@': 1457}), 6: (1, {'@': 1457}), 33: (1, {'@': 1457}), 7: (1, {'@': 1457}), 53: (1, {'@': 1457}), 69: (1, {'@': 1457}), 40: (1, {'@': 1457}), 41: (1, {'@': 1457}), 75: (1, {'@': 1457}), 73: (1, {'@': 1457}), 57: (1, {'@': 1457}), 43: (1, {'@': 1457}), 45: (1, {'@': 1457}), 27: (1, {'@': 1457}), 64: (1, {'@': 1457}), 34: (1, {'@': 1457}), 37: (1, {'@': 1457}), 54: (1, {'@': 1457}), 38: (1, {'@': 1457}), 74: (1, {'@': 1457}), 18: (1, {'@': 1457}), 58: (1, {'@': 1457}), 66: (1, {'@': 1457}), 2: (1, {'@': 1457}), 63: (1, {'@': 1457}), 52: (1, {'@': 1457}), 8: (1, {'@': 1457}), 71: (1, {'@': 1457}), 55: (1, {'@': 1457}), 1: (1, {'@': 1457}), 47: (1, {'@': 1457}), 48: (1, {'@': 1457}), 4: (1, {'@': 1457}), 50: (1, {'@': 1457}), 51: (1, {'@': 1457}), 9: (1, {'@': 1457}), 11: (1, {'@': 1457}), 15: (1, {'@': 1457}), 17: (1, {'@': 1457}), 26: (1, {'@': 1457}), 29: (1, {'@': 1457}), 30: (1, {'@': 1457}), 31: (1, {'@': 1457}), 67: (1, {'@': 1457}), 36: (1, {'@': 1457}), 68: (1, {'@': 1457}), 70: (1, {'@': 1457}), 72: (1, {'@': 1457})}, 1340: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 255: (0, 1221), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 439: (0, 1253), 46: (0, 781), 434: (0, 1214), 564: (0, 1143), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 436: (0, 1217), 96: (0, 789), 82: (0, 791), 98: (0, 793), 432: (0, 1242), 110: (0, 799), 19: (0, 800), 13: (0, 802), 562: (0, 1245), 563: (0, 1249), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 438: (0, 1230), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 256: (0, 1219), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 86: (0, 1257), 42: (0, 858), 123: (0, 856), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1341: {126: (1, {'@': 1536})}, 1342: {60: (0, 2202)}, 1343: {59: (1, {'@': 1510}), 60: (1, {'@': 1510}), 21: (1, {'@': 1510}), 22: (1, {'@': 1510}), 44: (1, {'@': 1510}), 126: (1, {'@': 1510}), 62: (1, {'@': 1510}), 61: (1, {'@': 1510}), 23: (1, {'@': 1510}), 25: (1, {'@': 1510}), 28: (1, {'@': 1510}), 49: (1, {'@': 1510}), 6: (1, {'@': 1510}), 33: (1, {'@': 1510}), 7: (1, {'@': 1510}), 53: (1, {'@': 1510}), 69: (1, {'@': 1510}), 40: (1, {'@': 1510}), 41: (1, {'@': 1510}), 75: (1, {'@': 1510}), 73: (1, {'@': 1510}), 57: (1, {'@': 1510}), 125: (1, {'@': 1510}), 127: (1, {'@': 1510}), 43: (1, {'@': 1510}), 45: (1, {'@': 1510}), 27: (1, {'@': 1510}), 64: (1, {'@': 1510}), 34: (1, {'@': 1510}), 37: (1, {'@': 1510}), 54: (1, {'@': 1510}), 38: (1, {'@': 1510}), 74: (1, {'@': 1510}), 18: (1, {'@': 1510}), 1: (1, {'@': 1510}), 2: (1, {'@': 1510}), 47: (1, {'@': 1510}), 48: (1, {'@': 1510}), 4: (1, {'@': 1510}), 50: (1, {'@': 1510}), 51: (1, {'@': 1510}), 52: (1, {'@': 1510}), 8: (1, {'@': 1510}), 9: (1, {'@': 1510}), 11: (1, {'@': 1510}), 55: (1, {'@': 1510}), 15: (1, {'@': 1510}), 17: (1, {'@': 1510}), 58: (1, {'@': 1510}), 26: (1, {'@': 1510}), 63: (1, {'@': 1510}), 29: (1, {'@': 1510}), 30: (1, {'@': 1510}), 31: (1, {'@': 1510}), 66: (1, {'@': 1510}), 67: (1, {'@': 1510}), 36: (1, {'@': 1510}), 68: (1, {'@': 1510}), 70: (1, {'@': 1510}), 71: (1, {'@': 1510}), 72: (1, {'@': 1510})}, 1344: {126: (0, 1323), 60: (1, {'@': 1414})}, 1345: {126: (1, {'@': 1534})}, 1346: {126: (0, 2067), 60: (1, {'@': 1413})}, 1347: {59: (1, {'@': 1488}), 60: (1, {'@': 1488}), 21: (1, {'@': 1488}), 22: (1, {'@': 1488}), 44: (1, {'@': 1488}), 126: (1, {'@': 1488}), 62: (1, {'@': 1488}), 61: (1, {'@': 1488}), 23: (1, {'@': 1488}), 25: (1, {'@': 1488}), 28: (1, {'@': 1488}), 49: (1, {'@': 1488}), 6: (1, {'@': 1488}), 33: (1, {'@': 1488}), 7: (1, {'@': 1488}), 53: (1, {'@': 1488}), 69: (1, {'@': 1488}), 40: (1, {'@': 1488}), 41: (1, {'@': 1488}), 75: (1, {'@': 1488}), 73: (1, {'@': 1488}), 57: (1, {'@': 1488}), 64: (1, {'@': 1488}), 34: (1, {'@': 1488}), 54: (1, {'@': 1488}), 18: (1, {'@': 1488}), 43: (1, {'@': 1488}), 1: (1, {'@': 1488}), 2: (1, {'@': 1488}), 45: (1, {'@': 1488}), 47: (1, {'@': 1488}), 48: (1, {'@': 1488}), 4: (1, {'@': 1488}), 50: (1, {'@': 1488}), 51: (1, {'@': 1488}), 52: (1, {'@': 1488}), 8: (1, {'@': 1488}), 9: (1, {'@': 1488}), 11: (1, {'@': 1488}), 55: (1, {'@': 1488}), 15: (1, {'@': 1488}), 17: (1, {'@': 1488}), 58: (1, {'@': 1488}), 26: (1, {'@': 1488}), 63: (1, {'@': 1488}), 27: (1, {'@': 1488}), 29: (1, {'@': 1488}), 30: (1, {'@': 1488}), 31: (1, {'@': 1488}), 66: (1, {'@': 1488}), 67: (1, {'@': 1488}), 36: (1, {'@': 1488}), 37: (1, {'@': 1488}), 68: (1, {'@': 1488}), 38: (1, {'@': 1488}), 70: (1, {'@': 1488}), 71: (1, {'@': 1488}), 72: (1, {'@': 1488}), 74: (1, {'@': 1488})}, 1348: {60: (0, 1339)}, 1349: {126: (1, {'@': 1537})}, 1350: {60: (0, 1317)}, 1351: {59: (1, {'@': 1507}), 60: (1, {'@': 1507}), 21: (1, {'@': 1507}), 22: (1, {'@': 1507}), 44: (1, {'@': 1507}), 126: (1, {'@': 1507}), 62: (1, {'@': 1507}), 61: (1, {'@': 1507}), 23: (1, {'@': 1507}), 25: (1, {'@': 1507}), 28: (1, {'@': 1507}), 49: (1, {'@': 1507}), 6: (1, {'@': 1507}), 33: (1, {'@': 1507}), 7: (1, {'@': 1507}), 53: (1, {'@': 1507}), 69: (1, {'@': 1507}), 40: (1, {'@': 1507}), 41: (1, {'@': 1507}), 75: (1, {'@': 1507}), 73: (1, {'@': 1507}), 57: (1, {'@': 1507}), 43: (1, {'@': 1507}), 45: (1, {'@': 1507}), 27: (1, {'@': 1507}), 64: (1, {'@': 1507}), 34: (1, {'@': 1507}), 37: (1, {'@': 1507}), 54: (1, {'@': 1507}), 38: (1, {'@': 1507}), 74: (1, {'@': 1507}), 18: (1, {'@': 1507}), 1: (1, {'@': 1507}), 2: (1, {'@': 1507}), 47: (1, {'@': 1507}), 48: (1, {'@': 1507}), 4: (1, {'@': 1507}), 50: (1, {'@': 1507}), 51: (1, {'@': 1507}), 52: (1, {'@': 1507}), 8: (1, {'@': 1507}), 9: (1, {'@': 1507}), 11: (1, {'@': 1507}), 55: (1, {'@': 1507}), 15: (1, {'@': 1507}), 17: (1, {'@': 1507}), 58: (1, {'@': 1507}), 26: (1, {'@': 1507}), 63: (1, {'@': 1507}), 29: (1, {'@': 1507}), 30: (1, {'@': 1507}), 31: (1, {'@': 1507}), 66: (1, {'@': 1507}), 67: (1, {'@': 1507}), 36: (1, {'@': 1507}), 68: (1, {'@': 1507}), 70: (1, {'@': 1507}), 71: (1, {'@': 1507}), 72: (1, {'@': 1507})}, 1352: {60: (1, {'@': 1421}), 126: (1, {'@': 1421})}, 1353: {146: (1, {'@': 1527})}, 1354: {60: (1, {'@': 1417}), 126: (1, {'@': 1417})}, 1355: {59: (1, {'@': 1514}), 60: (1, {'@': 1514}), 21: (1, {'@': 1514}), 22: (1, {'@': 1514}), 44: (1, {'@': 1514}), 126: (1, {'@': 1514}), 62: (1, {'@': 1514}), 61: (1, {'@': 1514}), 23: (1, {'@': 1514}), 25: (1, {'@': 1514}), 28: (1, {'@': 1514}), 49: (1, {'@': 1514}), 6: (1, {'@': 1514}), 33: (1, {'@': 1514}), 7: (1, {'@': 1514}), 53: (1, {'@': 1514}), 69: (1, {'@': 1514}), 40: (1, {'@': 1514}), 41: (1, {'@': 1514}), 75: (1, {'@': 1514}), 73: (1, {'@': 1514}), 57: (1, {'@': 1514}), 43: (1, {'@': 1514}), 1: (1, {'@': 1514}), 2: (1, {'@': 1514}), 45: (1, {'@': 1514}), 47: (1, {'@': 1514}), 48: (1, {'@': 1514}), 4: (1, {'@': 1514}), 50: (1, {'@': 1514}), 51: (1, {'@': 1514}), 52: (1, {'@': 1514}), 8: (1, {'@': 1514}), 9: (1, {'@': 1514}), 11: (1, {'@': 1514}), 54: (1, {'@': 1514}), 55: (1, {'@': 1514}), 15: (1, {'@': 1514}), 17: (1, {'@': 1514}), 18: (1, {'@': 1514}), 58: (1, {'@': 1514}), 26: (1, {'@': 1514}), 63: (1, {'@': 1514}), 27: (1, {'@': 1514}), 29: (1, {'@': 1514}), 30: (1, {'@': 1514}), 31: (1, {'@': 1514}), 64: (1, {'@': 1514}), 66: (1, {'@': 1514}), 67: (1, {'@': 1514}), 34: (1, {'@': 1514}), 36: (1, {'@': 1514}), 37: (1, {'@': 1514}), 68: (1, {'@': 1514}), 38: (1, {'@': 1514}), 70: (1, {'@': 1514}), 71: (1, {'@': 1514}), 72: (1, {'@': 1514}), 74: (1, {'@': 1514})}, 1356: {60: (1, {'@': 1418}), 126: (1, {'@': 1418})}, 1357: {126: (1, {'@': 1700})}, 1358: {126: (1, {'@': 1538})}, 1359: {60: (0, 2133)}, 1360: {60: (1, {'@': 1419}), 126: (1, {'@': 1419})}, 1361: {126: (1, {'@': 1524})}, 1362: {60: (1, {'@': 1420}), 126: (1, {'@': 1420})}, 1363: {126: (1, {'@': 1575}), 146: (1, {'@': 1575})}, 1364: {60: (0, 1331)}, 1365: {126: (1, {'@': 1533})}, 1366: {60: (0, 1333)}, 1367: {144: (0, 2316), 145: (0, 1580)}, 1368: {60: (0, 1336)}, 1369: {146: (1, {'@': 1529})}, 1370: {311: (0, 2361), 310: (0, 1612), 314: (0, 2369)}, 1371: {60: (0, 1347)}, 1372: {60: (0, 911)}, 1373: {146: (1, {'@': 1492})}, 1374: {60: (0, 1343)}, 1375: {57: (1, {'@': 886}), 60: (1, {'@': 886}), 6: (1, {'@': 886}), 7: (1, {'@': 886}), 61: (1, {'@': 886}), 126: (1, {'@': 886}), 45: (1, {'@': 886}), 37: (1, {'@': 886}), 38: (1, {'@': 886}), 47: (1, {'@': 886}), 26: (1, {'@': 886}), 27: (1, {'@': 886}), 4: (1, {'@': 886}), 28: (1, {'@': 886}), 50: (1, {'@': 886}), 53: (1, {'@': 886}), 67: (1, {'@': 886}), 29: (1, {'@': 886}), 30: (1, {'@': 886}), 15: (1, {'@': 886}), 1: (1, {'@': 886}), 43: (1, {'@': 886}), 2: (1, {'@': 886}), 44: (1, {'@': 886}), 48: (1, {'@': 886}), 49: (1, {'@': 886}), 51: (1, {'@': 886}), 52: (1, {'@': 886}), 8: (1, {'@': 886}), 9: (1, {'@': 886}), 11: (1, {'@': 886}), 54: (1, {'@': 886}), 55: (1, {'@': 886}), 17: (1, {'@': 886}), 18: (1, {'@': 886}), 58: (1, {'@': 886}), 59: (1, {'@': 886}), 21: (1, {'@': 886}), 22: (1, {'@': 886}), 62: (1, {'@': 886}), 23: (1, {'@': 886}), 25: (1, {'@': 886}), 63: (1, {'@': 886}), 31: (1, {'@': 886}), 33: (1, {'@': 886}), 64: (1, {'@': 886}), 66: (1, {'@': 886}), 34: (1, {'@': 886}), 36: (1, {'@': 886}), 68: (1, {'@': 886}), 69: (1, {'@': 886}), 70: (1, {'@': 886}), 71: (1, {'@': 886}), 40: (1, {'@': 886}), 72: (1, {'@': 886}), 41: (1, {'@': 886}), 73: (1, {'@': 886}), 74: (1, {'@': 886}), 75: (1, {'@': 886})}, 1376: {126: (1, {'@': 1531})}, 1377: {59: (1, {'@': 1397}), 60: (1, {'@': 1397}), 21: (1, {'@': 1397}), 22: (1, {'@': 1397}), 44: (1, {'@': 1397}), 126: (1, {'@': 1397}), 62: (1, {'@': 1397}), 61: (1, {'@': 1397}), 23: (1, {'@': 1397}), 25: (1, {'@': 1397}), 28: (1, {'@': 1397}), 49: (1, {'@': 1397}), 6: (1, {'@': 1397}), 33: (1, {'@': 1397}), 7: (1, {'@': 1397}), 53: (1, {'@': 1397}), 69: (1, {'@': 1397}), 40: (1, {'@': 1397}), 41: (1, {'@': 1397}), 75: (1, {'@': 1397}), 73: (1, {'@': 1397}), 57: (1, {'@': 1397}), 174: (1, {'@': 1397}), 175: (1, {'@': 1397}), 176: (1, {'@': 1397}), 177: (1, {'@': 1397}), 48: (1, {'@': 1397}), 72: (1, {'@': 1397}), 178: (1, {'@': 1397}), 179: (1, {'@': 1397}), 43: (1, {'@': 1397}), 1: (1, {'@': 1397}), 2: (1, {'@': 1397}), 45: (1, {'@': 1397}), 47: (1, {'@': 1397}), 4: (1, {'@': 1397}), 50: (1, {'@': 1397}), 51: (1, {'@': 1397}), 52: (1, {'@': 1397}), 8: (1, {'@': 1397}), 9: (1, {'@': 1397}), 11: (1, {'@': 1397}), 54: (1, {'@': 1397}), 55: (1, {'@': 1397}), 15: (1, {'@': 1397}), 17: (1, {'@': 1397}), 18: (1, {'@': 1397}), 58: (1, {'@': 1397}), 26: (1, {'@': 1397}), 63: (1, {'@': 1397}), 27: (1, {'@': 1397}), 29: (1, {'@': 1397}), 30: (1, {'@': 1397}), 31: (1, {'@': 1397}), 64: (1, {'@': 1397}), 66: (1, {'@': 1397}), 67: (1, {'@': 1397}), 34: (1, {'@': 1397}), 36: (1, {'@': 1397}), 37: (1, {'@': 1397}), 68: (1, {'@': 1397}), 38: (1, {'@': 1397}), 70: (1, {'@': 1397}), 71: (1, {'@': 1397}), 74: (1, {'@': 1397})}, 1378: {146: (1, {'@': 1528})}, 1379: {77: (0, 17), 78: (0, 1960), 79: (0, 1973), 12: (0, 396), 82: (0, 791), 83: (0, 809), 84: (0, 811), 85: (0, 816), 570: (0, 1330), 256: (0, 1332), 10: (0, 826), 87: (0, 842), 35: (0, 844), 571: (0, 1334), 88: (0, 848), 90: (0, 853), 91: (0, 863), 474: (0, 1337), 92: (0, 1944), 379: (0, 1341), 255: (0, 1221), 572: (0, 1345), 573: (0, 1349), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 56: (0, 783), 95: (0, 786), 574: (0, 1358), 96: (0, 789), 98: (0, 793), 19: (0, 800), 13: (0, 802), 32: (0, 807), 376: (0, 1361), 99: (0, 812), 100: (0, 817), 20: (0, 822), 102: (0, 823), 103: (0, 825), 575: (0, 1365), 105: (0, 830), 65: (0, 834), 577: (0, 1376), 106: (0, 838), 578: (0, 1382), 579: (0, 1386), 108: (0, 400), 109: (0, 390), 46: (0, 781), 580: (0, 1390), 110: (0, 799), 111: (0, 821), 14: (0, 399), 113: (0, 828), 114: (0, 832), 581: (0, 1398), 380: (0, 1402), 0: (0, 846), 42: (0, 858), 39: (0, 860), 115: (0, 44), 86: (0, 1408), 582: (0, 1412), 116: (0, 780), 5: (0, 787), 117: (0, 804), 24: (0, 814), 118: (0, 819), 119: (0, 836), 120: (0, 840), 122: (0, 850), 3: (0, 855), 123: (0, 856), 576: (0, 1357), 124: (0, 864)}, 1380: {59: (1, {'@': 1109}), 60: (1, {'@': 1109}), 21: (1, {'@': 1109}), 22: (1, {'@': 1109}), 44: (1, {'@': 1109}), 126: (1, {'@': 1109}), 62: (1, {'@': 1109}), 61: (1, {'@': 1109}), 23: (1, {'@': 1109}), 25: (1, {'@': 1109}), 28: (1, {'@': 1109}), 49: (1, {'@': 1109}), 6: (1, {'@': 1109}), 33: (1, {'@': 1109}), 7: (1, {'@': 1109}), 53: (1, {'@': 1109}), 69: (1, {'@': 1109}), 40: (1, {'@': 1109}), 41: (1, {'@': 1109}), 75: (1, {'@': 1109}), 73: (1, {'@': 1109}), 57: (1, {'@': 1109}), 43: (1, {'@': 1109}), 1: (1, {'@': 1109}), 2: (1, {'@': 1109}), 45: (1, {'@': 1109}), 47: (1, {'@': 1109}), 48: (1, {'@': 1109}), 4: (1, {'@': 1109}), 50: (1, {'@': 1109}), 51: (1, {'@': 1109}), 52: (1, {'@': 1109}), 8: (1, {'@': 1109}), 9: (1, {'@': 1109}), 11: (1, {'@': 1109}), 54: (1, {'@': 1109}), 55: (1, {'@': 1109}), 15: (1, {'@': 1109}), 17: (1, {'@': 1109}), 18: (1, {'@': 1109}), 58: (1, {'@': 1109}), 26: (1, {'@': 1109}), 63: (1, {'@': 1109}), 27: (1, {'@': 1109}), 29: (1, {'@': 1109}), 30: (1, {'@': 1109}), 31: (1, {'@': 1109}), 64: (1, {'@': 1109}), 66: (1, {'@': 1109}), 67: (1, {'@': 1109}), 34: (1, {'@': 1109}), 36: (1, {'@': 1109}), 37: (1, {'@': 1109}), 68: (1, {'@': 1109}), 38: (1, {'@': 1109}), 70: (1, {'@': 1109}), 71: (1, {'@': 1109}), 72: (1, {'@': 1109}), 74: (1, {'@': 1109})}, 1381: {60: (0, 1351)}, 1382: {126: (1, {'@': 1520})}, 1383: {126: (1, {'@': 1699})}, 1384: {59: (1, {'@': 1482}), 60: (1, {'@': 1482}), 21: (1, {'@': 1482}), 22: (1, {'@': 1482}), 44: (1, {'@': 1482}), 126: (1, {'@': 1482}), 62: (1, {'@': 1482}), 61: (1, {'@': 1482}), 23: (1, {'@': 1482}), 25: (1, {'@': 1482}), 28: (1, {'@': 1482}), 49: (1, {'@': 1482}), 6: (1, {'@': 1482}), 33: (1, {'@': 1482}), 7: (1, {'@': 1482}), 53: (1, {'@': 1482}), 69: (1, {'@': 1482}), 40: (1, {'@': 1482}), 41: (1, {'@': 1482}), 75: (1, {'@': 1482}), 73: (1, {'@': 1482}), 57: (1, {'@': 1482}), 43: (1, {'@': 1482}), 45: (1, {'@': 1482}), 27: (1, {'@': 1482}), 64: (1, {'@': 1482}), 34: (1, {'@': 1482}), 37: (1, {'@': 1482}), 54: (1, {'@': 1482}), 38: (1, {'@': 1482}), 74: (1, {'@': 1482}), 18: (1, {'@': 1482}), 1: (1, {'@': 1482}), 2: (1, {'@': 1482}), 47: (1, {'@': 1482}), 48: (1, {'@': 1482}), 4: (1, {'@': 1482}), 50: (1, {'@': 1482}), 51: (1, {'@': 1482}), 52: (1, {'@': 1482}), 8: (1, {'@': 1482}), 9: (1, {'@': 1482}), 11: (1, {'@': 1482}), 55: (1, {'@': 1482}), 15: (1, {'@': 1482}), 17: (1, {'@': 1482}), 58: (1, {'@': 1482}), 26: (1, {'@': 1482}), 63: (1, {'@': 1482}), 29: (1, {'@': 1482}), 30: (1, {'@': 1482}), 31: (1, {'@': 1482}), 66: (1, {'@': 1482}), 67: (1, {'@': 1482}), 36: (1, {'@': 1482}), 68: (1, {'@': 1482}), 70: (1, {'@': 1482}), 71: (1, {'@': 1482}), 72: (1, {'@': 1482})}, 1385: {60: (0, 1355)}, 1386: {126: (1, {'@': 1519})}, 1387: {146: (0, 1367)}, 1388: {59: (1, {'@': 1498}), 60: (1, {'@': 1498}), 21: (1, {'@': 1498}), 22: (1, {'@': 1498}), 44: (1, {'@': 1498}), 126: (1, {'@': 1498}), 62: (1, {'@': 1498}), 61: (1, {'@': 1498}), 23: (1, {'@': 1498}), 25: (1, {'@': 1498}), 28: (1, {'@': 1498}), 49: (1, {'@': 1498}), 6: (1, {'@': 1498}), 33: (1, {'@': 1498}), 7: (1, {'@': 1498}), 53: (1, {'@': 1498}), 69: (1, {'@': 1498}), 40: (1, {'@': 1498}), 41: (1, {'@': 1498}), 75: (1, {'@': 1498}), 73: (1, {'@': 1498}), 57: (1, {'@': 1498}), 43: (1, {'@': 1498}), 45: (1, {'@': 1498}), 27: (1, {'@': 1498}), 64: (1, {'@': 1498}), 34: (1, {'@': 1498}), 37: (1, {'@': 1498}), 54: (1, {'@': 1498}), 38: (1, {'@': 1498}), 74: (1, {'@': 1498}), 18: (1, {'@': 1498}), 1: (1, {'@': 1498}), 2: (1, {'@': 1498}), 47: (1, {'@': 1498}), 48: (1, {'@': 1498}), 4: (1, {'@': 1498}), 50: (1, {'@': 1498}), 51: (1, {'@': 1498}), 52: (1, {'@': 1498}), 8: (1, {'@': 1498}), 9: (1, {'@': 1498}), 11: (1, {'@': 1498}), 55: (1, {'@': 1498}), 15: (1, {'@': 1498}), 17: (1, {'@': 1498}), 58: (1, {'@': 1498}), 26: (1, {'@': 1498}), 63: (1, {'@': 1498}), 29: (1, {'@': 1498}), 30: (1, {'@': 1498}), 31: (1, {'@': 1498}), 66: (1, {'@': 1498}), 67: (1, {'@': 1498}), 36: (1, {'@': 1498}), 68: (1, {'@': 1498}), 70: (1, {'@': 1498}), 71: (1, {'@': 1498}), 72: (1, {'@': 1498})}, 1389: {146: (0, 1449)}, 1390: {126: (1, {'@': 1522})}, 1391: {146: (1, {'@': 1401})}, 1392: {59: (1, {'@': 1494}), 60: (1, {'@': 1494}), 21: (1, {'@': 1494}), 22: (1, {'@': 1494}), 44: (1, {'@': 1494}), 126: (1, {'@': 1494}), 62: (1, {'@': 1494}), 61: (1, {'@': 1494}), 23: (1, {'@': 1494}), 25: (1, {'@': 1494}), 28: (1, {'@': 1494}), 49: (1, {'@': 1494}), 6: (1, {'@': 1494}), 33: (1, {'@': 1494}), 7: (1, {'@': 1494}), 53: (1, {'@': 1494}), 69: (1, {'@': 1494}), 40: (1, {'@': 1494}), 41: (1, {'@': 1494}), 75: (1, {'@': 1494}), 73: (1, {'@': 1494}), 57: (1, {'@': 1494}), 64: (1, {'@': 1494}), 34: (1, {'@': 1494}), 54: (1, {'@': 1494}), 18: (1, {'@': 1494}), 43: (1, {'@': 1494}), 1: (1, {'@': 1494}), 2: (1, {'@': 1494}), 45: (1, {'@': 1494}), 47: (1, {'@': 1494}), 48: (1, {'@': 1494}), 4: (1, {'@': 1494}), 50: (1, {'@': 1494}), 51: (1, {'@': 1494}), 52: (1, {'@': 1494}), 8: (1, {'@': 1494}), 9: (1, {'@': 1494}), 11: (1, {'@': 1494}), 55: (1, {'@': 1494}), 15: (1, {'@': 1494}), 17: (1, {'@': 1494}), 58: (1, {'@': 1494}), 26: (1, {'@': 1494}), 63: (1, {'@': 1494}), 27: (1, {'@': 1494}), 29: (1, {'@': 1494}), 30: (1, {'@': 1494}), 31: (1, {'@': 1494}), 66: (1, {'@': 1494}), 67: (1, {'@': 1494}), 36: (1, {'@': 1494}), 37: (1, {'@': 1494}), 68: (1, {'@': 1494}), 38: (1, {'@': 1494}), 70: (1, {'@': 1494}), 71: (1, {'@': 1494}), 72: (1, {'@': 1494}), 74: (1, {'@': 1494})}, 1393: {60: (0, 561)}, 1394: {146: (0, 929)}, 1395: {146: (1, {'@': 1402})}, 1396: {59: (1, {'@': 1107}), 60: (1, {'@': 1107}), 21: (1, {'@': 1107}), 22: (1, {'@': 1107}), 44: (1, {'@': 1107}), 126: (1, {'@': 1107}), 62: (1, {'@': 1107}), 61: (1, {'@': 1107}), 23: (1, {'@': 1107}), 25: (1, {'@': 1107}), 28: (1, {'@': 1107}), 49: (1, {'@': 1107}), 6: (1, {'@': 1107}), 33: (1, {'@': 1107}), 7: (1, {'@': 1107}), 53: (1, {'@': 1107}), 69: (1, {'@': 1107}), 40: (1, {'@': 1107}), 41: (1, {'@': 1107}), 75: (1, {'@': 1107}), 73: (1, {'@': 1107}), 57: (1, {'@': 1107}), 43: (1, {'@': 1107}), 1: (1, {'@': 1107}), 2: (1, {'@': 1107}), 45: (1, {'@': 1107}), 47: (1, {'@': 1107}), 48: (1, {'@': 1107}), 4: (1, {'@': 1107}), 50: (1, {'@': 1107}), 51: (1, {'@': 1107}), 52: (1, {'@': 1107}), 8: (1, {'@': 1107}), 9: (1, {'@': 1107}), 11: (1, {'@': 1107}), 54: (1, {'@': 1107}), 55: (1, {'@': 1107}), 15: (1, {'@': 1107}), 17: (1, {'@': 1107}), 18: (1, {'@': 1107}), 58: (1, {'@': 1107}), 26: (1, {'@': 1107}), 63: (1, {'@': 1107}), 27: (1, {'@': 1107}), 29: (1, {'@': 1107}), 30: (1, {'@': 1107}), 31: (1, {'@': 1107}), 64: (1, {'@': 1107}), 66: (1, {'@': 1107}), 67: (1, {'@': 1107}), 34: (1, {'@': 1107}), 36: (1, {'@': 1107}), 37: (1, {'@': 1107}), 68: (1, {'@': 1107}), 38: (1, {'@': 1107}), 70: (1, {'@': 1107}), 71: (1, {'@': 1107}), 72: (1, {'@': 1107}), 74: (1, {'@': 1107})}, 1397: {60: (0, 1396)}, 1398: {126: (1, {'@': 1518})}, 1399: {60: (0, 1380)}, 1400: {60: (0, 1410)}, 1401: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 86: (0, 1437), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 312: (0, 1417), 592: (0, 1422), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 596: (0, 1440), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 111: (0, 821), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 313: (0, 2377), 65: (0, 834), 594: (0, 1576), 42: (0, 858), 119: (0, 836), 106: (0, 838), 591: (0, 1420), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 595: (0, 1436), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1402: {112: (0, 927)}, 1403: {60: (0, 1392)}, 1404: {60: (0, 1377)}, 1405: {126: (0, 939)}, 1406: {60: (0, 1384)}, 1407: {126: (0, 1590), 60: (1, {'@': 629})}, 1408: {126: (1, {'@': 1526})}, 1409: {60: (0, 1388)}, 1410: {57: (1, {'@': 1461}), 60: (1, {'@': 1461}), 6: (1, {'@': 1461}), 7: (1, {'@': 1461}), 61: (1, {'@': 1461}), 126: (1, {'@': 1461}), 45: (1, {'@': 1461}), 37: (1, {'@': 1461}), 38: (1, {'@': 1461}), 47: (1, {'@': 1461}), 26: (1, {'@': 1461}), 27: (1, {'@': 1461}), 4: (1, {'@': 1461}), 28: (1, {'@': 1461}), 50: (1, {'@': 1461}), 53: (1, {'@': 1461}), 67: (1, {'@': 1461}), 29: (1, {'@': 1461}), 30: (1, {'@': 1461}), 15: (1, {'@': 1461}), 43: (1, {'@': 1461}), 21: (1, {'@': 1461}), 44: (1, {'@': 1461}), 33: (1, {'@': 1461}), 64: (1, {'@': 1461}), 34: (1, {'@': 1461}), 54: (1, {'@': 1461}), 69: (1, {'@': 1461}), 40: (1, {'@': 1461}), 74: (1, {'@': 1461}), 41: (1, {'@': 1461}), 75: (1, {'@': 1461}), 18: (1, {'@': 1461}), 1: (1, {'@': 1461}), 2: (1, {'@': 1461}), 48: (1, {'@': 1461}), 49: (1, {'@': 1461}), 51: (1, {'@': 1461}), 52: (1, {'@': 1461}), 8: (1, {'@': 1461}), 9: (1, {'@': 1461}), 11: (1, {'@': 1461}), 55: (1, {'@': 1461}), 17: (1, {'@': 1461}), 58: (1, {'@': 1461}), 59: (1, {'@': 1461}), 22: (1, {'@': 1461}), 62: (1, {'@': 1461}), 23: (1, {'@': 1461}), 25: (1, {'@': 1461}), 63: (1, {'@': 1461}), 31: (1, {'@': 1461}), 66: (1, {'@': 1461}), 36: (1, {'@': 1461}), 68: (1, {'@': 1461}), 70: (1, {'@': 1461}), 71: (1, {'@': 1461}), 72: (1, {'@': 1461}), 73: (1, {'@': 1461})}, 1411: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 601: (0, 2258), 116: (0, 780), 606: (0, 1413), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 602: (0, 2268), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 603: (0, 2276), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 604: (0, 2283), 86: (0, 2286), 119: (0, 836), 106: (0, 838), 605: (0, 2294), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1412: {126: (1, {'@': 1521})}, 1413: {126: (1, {'@': 1676}), 146: (1, {'@': 1676})}, 1414: {146: (1, {'@': 1465})}, 1415: {146: (1, {'@': 1530})}, 1416: {6: (1, {'@': 956}), 60: (1, {'@': 956}), 7: (1, {'@': 956}), 61: (1, {'@': 956}), 126: (1, {'@': 956}), 45: (1, {'@': 956}), 37: (1, {'@': 956}), 38: (1, {'@': 956}), 47: (1, {'@': 956}), 26: (1, {'@': 956}), 27: (1, {'@': 956}), 4: (1, {'@': 956}), 28: (1, {'@': 956}), 50: (1, {'@': 956}), 57: (1, {'@': 956}), 43: (1, {'@': 956}), 1: (1, {'@': 956}), 2: (1, {'@': 956}), 44: (1, {'@': 956}), 48: (1, {'@': 956}), 49: (1, {'@': 956}), 51: (1, {'@': 956}), 52: (1, {'@': 956}), 8: (1, {'@': 956}), 9: (1, {'@': 956}), 53: (1, {'@': 956}), 11: (1, {'@': 956}), 54: (1, {'@': 956}), 55: (1, {'@': 956}), 15: (1, {'@': 956}), 17: (1, {'@': 956}), 18: (1, {'@': 956}), 58: (1, {'@': 956}), 59: (1, {'@': 956}), 21: (1, {'@': 956}), 22: (1, {'@': 956}), 62: (1, {'@': 956}), 23: (1, {'@': 956}), 25: (1, {'@': 956}), 63: (1, {'@': 956}), 29: (1, {'@': 956}), 30: (1, {'@': 956}), 31: (1, {'@': 956}), 33: (1, {'@': 956}), 64: (1, {'@': 956}), 66: (1, {'@': 956}), 67: (1, {'@': 956}), 34: (1, {'@': 956}), 36: (1, {'@': 956}), 68: (1, {'@': 956}), 69: (1, {'@': 956}), 70: (1, {'@': 956}), 71: (1, {'@': 956}), 40: (1, {'@': 956}), 72: (1, {'@': 956}), 41: (1, {'@': 956}), 73: (1, {'@': 956}), 74: (1, {'@': 956}), 75: (1, {'@': 956})}, 1417: {126: (1, {'@': 632}), 60: (1, {'@': 632})}, 1418: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 1606)}, 1419: {126: (0, 948), 146: (1, {'@': 1399})}, 1420: {126: (1, {'@': 637}), 60: (1, {'@': 637})}, 1421: {126: (0, 906), 146: (1, {'@': 1400})}, 1422: {126: (1, {'@': 633}), 60: (1, {'@': 633})}, 1423: {6: (1, {'@': 955}), 60: (1, {'@': 955}), 7: (1, {'@': 955}), 61: (1, {'@': 955}), 126: (1, {'@': 955}), 45: (1, {'@': 955}), 37: (1, {'@': 955}), 38: (1, {'@': 955}), 47: (1, {'@': 955}), 26: (1, {'@': 955}), 27: (1, {'@': 955}), 4: (1, {'@': 955}), 28: (1, {'@': 955}), 50: (1, {'@': 955}), 57: (1, {'@': 955}), 43: (1, {'@': 955}), 1: (1, {'@': 955}), 2: (1, {'@': 955}), 44: (1, {'@': 955}), 48: (1, {'@': 955}), 49: (1, {'@': 955}), 51: (1, {'@': 955}), 52: (1, {'@': 955}), 8: (1, {'@': 955}), 9: (1, {'@': 955}), 53: (1, {'@': 955}), 11: (1, {'@': 955}), 54: (1, {'@': 955}), 55: (1, {'@': 955}), 15: (1, {'@': 955}), 17: (1, {'@': 955}), 18: (1, {'@': 955}), 58: (1, {'@': 955}), 59: (1, {'@': 955}), 21: (1, {'@': 955}), 22: (1, {'@': 955}), 62: (1, {'@': 955}), 23: (1, {'@': 955}), 25: (1, {'@': 955}), 63: (1, {'@': 955}), 29: (1, {'@': 955}), 30: (1, {'@': 955}), 31: (1, {'@': 955}), 33: (1, {'@': 955}), 64: (1, {'@': 955}), 66: (1, {'@': 955}), 67: (1, {'@': 955}), 34: (1, {'@': 955}), 36: (1, {'@': 955}), 68: (1, {'@': 955}), 69: (1, {'@': 955}), 70: (1, {'@': 955}), 71: (1, {'@': 955}), 40: (1, {'@': 955}), 72: (1, {'@': 955}), 41: (1, {'@': 955}), 73: (1, {'@': 955}), 74: (1, {'@': 955}), 75: (1, {'@': 955})}, 1424: {146: (1, {'@': 1404}), 126: (1, {'@': 1404})}, 1425: {60: (1, {'@': 631})}, 1426: {57: (1, {'@': 1459}), 60: (1, {'@': 1459}), 6: (1, {'@': 1459}), 7: (1, {'@': 1459}), 61: (1, {'@': 1459}), 126: (1, {'@': 1459}), 45: (1, {'@': 1459}), 37: (1, {'@': 1459}), 38: (1, {'@': 1459}), 47: (1, {'@': 1459}), 26: (1, {'@': 1459}), 27: (1, {'@': 1459}), 4: (1, {'@': 1459}), 28: (1, {'@': 1459}), 50: (1, {'@': 1459}), 53: (1, {'@': 1459}), 67: (1, {'@': 1459}), 29: (1, {'@': 1459}), 30: (1, {'@': 1459}), 15: (1, {'@': 1459}), 43: (1, {'@': 1459}), 21: (1, {'@': 1459}), 44: (1, {'@': 1459}), 33: (1, {'@': 1459}), 64: (1, {'@': 1459}), 34: (1, {'@': 1459}), 54: (1, {'@': 1459}), 69: (1, {'@': 1459}), 40: (1, {'@': 1459}), 74: (1, {'@': 1459}), 41: (1, {'@': 1459}), 75: (1, {'@': 1459}), 18: (1, {'@': 1459}), 1: (1, {'@': 1459}), 2: (1, {'@': 1459}), 48: (1, {'@': 1459}), 49: (1, {'@': 1459}), 51: (1, {'@': 1459}), 52: (1, {'@': 1459}), 8: (1, {'@': 1459}), 9: (1, {'@': 1459}), 11: (1, {'@': 1459}), 55: (1, {'@': 1459}), 17: (1, {'@': 1459}), 58: (1, {'@': 1459}), 59: (1, {'@': 1459}), 22: (1, {'@': 1459}), 62: (1, {'@': 1459}), 23: (1, {'@': 1459}), 25: (1, {'@': 1459}), 63: (1, {'@': 1459}), 31: (1, {'@': 1459}), 66: (1, {'@': 1459}), 36: (1, {'@': 1459}), 68: (1, {'@': 1459}), 70: (1, {'@': 1459}), 71: (1, {'@': 1459}), 72: (1, {'@': 1459}), 73: (1, {'@': 1459})}, 1427: {146: (0, 943)}, 1428: {60: (1, {'@': 638})}, 1429: {6: (1, {'@': 951}), 60: (1, {'@': 951}), 7: (1, {'@': 951}), 61: (1, {'@': 951}), 126: (1, {'@': 951}), 45: (1, {'@': 951}), 37: (1, {'@': 951}), 38: (1, {'@': 951}), 47: (1, {'@': 951}), 26: (1, {'@': 951}), 27: (1, {'@': 951}), 4: (1, {'@': 951}), 28: (1, {'@': 951}), 50: (1, {'@': 951}), 57: (1, {'@': 951}), 43: (1, {'@': 951}), 1: (1, {'@': 951}), 2: (1, {'@': 951}), 44: (1, {'@': 951}), 48: (1, {'@': 951}), 49: (1, {'@': 951}), 51: (1, {'@': 951}), 52: (1, {'@': 951}), 8: (1, {'@': 951}), 9: (1, {'@': 951}), 53: (1, {'@': 951}), 11: (1, {'@': 951}), 54: (1, {'@': 951}), 55: (1, {'@': 951}), 15: (1, {'@': 951}), 17: (1, {'@': 951}), 18: (1, {'@': 951}), 58: (1, {'@': 951}), 59: (1, {'@': 951}), 21: (1, {'@': 951}), 22: (1, {'@': 951}), 62: (1, {'@': 951}), 23: (1, {'@': 951}), 25: (1, {'@': 951}), 63: (1, {'@': 951}), 29: (1, {'@': 951}), 30: (1, {'@': 951}), 31: (1, {'@': 951}), 33: (1, {'@': 951}), 64: (1, {'@': 951}), 66: (1, {'@': 951}), 67: (1, {'@': 951}), 34: (1, {'@': 951}), 36: (1, {'@': 951}), 68: (1, {'@': 951}), 69: (1, {'@': 951}), 70: (1, {'@': 951}), 71: (1, {'@': 951}), 40: (1, {'@': 951}), 72: (1, {'@': 951}), 41: (1, {'@': 951}), 73: (1, {'@': 951}), 74: (1, {'@': 951}), 75: (1, {'@': 951})}, 1430: {146: (1, {'@': 1403}), 126: (1, {'@': 1403})}, 1431: {126: (0, 1401), 649: (0, 1407), 60: (1, {'@': 630})}, 1432: {126: (1, {'@': 1565})}, 1433: {146: (0, 955)}, 1434: {126: (1, {'@': 1566})}, 1435: {146: (0, 950)}, 1436: {126: (1, {'@': 636}), 60: (1, {'@': 636})}, 1437: {126: (1, {'@': 634}), 60: (1, {'@': 634})}, 1438: {126: (1, {'@': 1567})}, 1439: {60: (0, 952)}, 1440: {126: (1, {'@': 635}), 60: (1, {'@': 635})}, 1441: {144: (0, 2316), 145: (0, 1604)}, 1442: {60: (0, 963)}, 1443: {126: (1, {'@': 1696})}, 1444: {60: (0, 704)}, 1445: {146: (0, 964)}, 1446: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 86: (0, 1617), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1447: {126: (0, 985), 146: (1, {'@': 888})}, 1448: {146: (0, 968)}, 1449: {144: (0, 2316), 145: (0, 1584)}, 1450: {312: (0, 734), 313: (0, 2377)}, 1451: {60: (0, 958)}, 1452: {126: (0, 1418), 60: (0, 1423)}, 1453: {144: (0, 2316), 145: (0, 1624)}, 1454: {60: (1, {'@': 1362}), 57: (1, {'@': 1362})}, 1455: {146: (1, {'@': 890})}, 1456: {57: (1, {'@': 1128}), 60: (1, {'@': 1128}), 59: (1, {'@': 1128}), 7: (1, {'@': 1128}), 22: (1, {'@': 1128}), 34: (1, {'@': 1128}), 53: (1, {'@': 1128}), 126: (1, {'@': 1128}), 69: (1, {'@': 1128}), 49: (1, {'@': 1128})}, 1457: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 194: (0, 406), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 86: (0, 409), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1458: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 124: (0, 864), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 194: (0, 2480), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 86: (0, 2483)}, 1459: {126: (0, 1815)}, 1460: {57: (1, {'@': 1132}), 60: (1, {'@': 1132}), 59: (1, {'@': 1132}), 7: (1, {'@': 1132}), 22: (1, {'@': 1132}), 34: (1, {'@': 1132}), 53: (1, {'@': 1132}), 126: (1, {'@': 1132}), 69: (1, {'@': 1132}), 49: (1, {'@': 1132})}, 1461: {112: (0, 1689)}, 1462: {112: (0, 73)}, 1463: {146: (1, {'@': 576}), 126: (1, {'@': 576})}, 1464: {60: (1, {'@': 360}), 57: (1, {'@': 360})}, 1465: {268: (1, {'@': 620}), 60: (1, {'@': 620}), 126: (1, {'@': 620}), 67: (1, {'@': 620}), 270: (1, {'@': 620}), 4: (1, {'@': 620}), 266: (1, {'@': 620}), 30: (1, {'@': 620}), 57: (1, {'@': 620})}, 1466: {57: (1, {'@': 1131}), 60: (1, {'@': 1131}), 59: (1, {'@': 1131}), 7: (1, {'@': 1131}), 22: (1, {'@': 1131}), 34: (1, {'@': 1131}), 53: (1, {'@': 1131}), 126: (1, {'@': 1131}), 69: (1, {'@': 1131}), 49: (1, {'@': 1131})}, 1467: {200: (0, 1840), 22: (0, 389), 48: (0, 1843), 53: (0, 387), 58: (0, 1666), 33: (0, 383), 183: (0, 1844), 7: (0, 45), 197: (0, 1847), 164: (0, 1850), 59: (0, 363), 208: (0, 1854), 396: (0, 1858), 75: (0, 341), 36: (0, 15), 49: (0, 335), 172: (0, 1861), 28: (0, 33), 212: (0, 1865), 180: (0, 1871), 34: (0, 1589), 61: (0, 25), 397: (0, 1875), 72: (0, 1882), 206: (0, 1884), 69: (0, 1760), 204: (0, 1887), 198: (0, 1891), 296: (0, 1896), 6: (0, 20), 31: (0, 1901), 9: (0, 1906), 392: (0, 1911), 629: (0, 1915), 185: (0, 1918), 395: (0, 1921), 398: (0, 1926), 287: (0, 1931), 0: (1, {'@': 435}), 3: (1, {'@': 435}), 20: (1, {'@': 435}), 32: (1, {'@': 435}), 65: (1, {'@': 435}), 10: (1, {'@': 435}), 35: (1, {'@': 435}), 12: (1, {'@': 435}), 46: (1, {'@': 435}), 24: (1, {'@': 435}), 14: (1, {'@': 435}), 13: (1, {'@': 435}), 39: (1, {'@': 435}), 42: (1, {'@': 435}), 56: (1, {'@': 435}), 16: (1, {'@': 435}), 5: (1, {'@': 435}), 19: (1, {'@': 435}), 60: (1, {'@': 1136}), 57: (1, {'@': 1136})}, 1468: {268: (1, {'@': 615}), 60: (1, {'@': 615}), 126: (1, {'@': 615}), 67: (1, {'@': 615}), 270: (1, {'@': 615}), 4: (1, {'@': 615}), 266: (1, {'@': 615}), 30: (1, {'@': 615}), 57: (1, {'@': 615})}, 1469: {146: (0, 770)}, 1470: {112: (0, 59), 268: (1, {'@': 645}), 60: (1, {'@': 645}), 126: (1, {'@': 645}), 67: (1, {'@': 645}), 270: (1, {'@': 645}), 4: (1, {'@': 645}), 266: (1, {'@': 645}), 30: (1, {'@': 645}), 57: (1, {'@': 645})}, 1471: {57: (1, {'@': 1134}), 60: (1, {'@': 1134}), 59: (1, {'@': 1134}), 7: (1, {'@': 1134}), 22: (1, {'@': 1134}), 34: (1, {'@': 1134}), 53: (1, {'@': 1134}), 126: (1, {'@': 1134}), 69: (1, {'@': 1134}), 49: (1, {'@': 1134})}, 1472: {268: (1, {'@': 617}), 60: (1, {'@': 617}), 126: (1, {'@': 617}), 67: (1, {'@': 617}), 270: (1, {'@': 617}), 4: (1, {'@': 617}), 266: (1, {'@': 617}), 30: (1, {'@': 617}), 57: (1, {'@': 617})}, 1473: {60: (1, {'@': 778}), 57: (1, {'@': 778})}, 1474: {57: (1, {'@': 1133}), 60: (1, {'@': 1133}), 59: (1, {'@': 1133}), 7: (1, {'@': 1133}), 22: (1, {'@': 1133}), 34: (1, {'@': 1133}), 53: (1, {'@': 1133}), 126: (1, {'@': 1133}), 69: (1, {'@': 1133}), 49: (1, {'@': 1133})}, 1475: {60: (1, {'@': 334}), 57: (1, {'@': 334})}, 1476: {268: (1, {'@': 616}), 60: (1, {'@': 616}), 126: (1, {'@': 616}), 67: (1, {'@': 616}), 270: (1, {'@': 616}), 4: (1, {'@': 616}), 266: (1, {'@': 616}), 30: (1, {'@': 616}), 57: (1, {'@': 616})}, 1477: {22: (0, 389), 48: (0, 1843), 7: (0, 45), 390: (0, 1819), 177: (0, 1812), 49: (0, 335), 391: (0, 1837), 393: (0, 1831), 179: (0, 1835), 206: (0, 1935), 198: (0, 1940), 72: (0, 1882), 392: (0, 1945), 178: (0, 1950), 180: (0, 1955), 628: (0, 1958), 394: (0, 1961), 395: (0, 1966), 60: (1, {'@': 588}), 57: (1, {'@': 588})}, 1478: {60: (1, {'@': 1123}), 57: (1, {'@': 1123})}, 1479: {60: (1, {'@': 611}), 57: (1, {'@': 611})}, 1480: {146: (0, 1311)}, 1481: {57: (1, {'@': 1130}), 60: (1, {'@': 1130}), 59: (1, {'@': 1130}), 7: (1, {'@': 1130}), 22: (1, {'@': 1130}), 34: (1, {'@': 1130}), 53: (1, {'@': 1130}), 126: (1, {'@': 1130}), 69: (1, {'@': 1130}), 49: (1, {'@': 1130})}, 1482: {57: (1, {'@': 803}), 60: (1, {'@': 803})}, 1483: {268: (1, {'@': 619}), 60: (1, {'@': 619}), 126: (1, {'@': 619}), 67: (1, {'@': 619}), 270: (1, {'@': 619}), 4: (1, {'@': 619}), 266: (1, {'@': 619}), 30: (1, {'@': 619}), 57: (1, {'@': 619})}, 1484: {60: (0, 1832)}, 1485: {22: (0, 389), 53: (0, 387), 7: (0, 45), 198: (0, 1827), 402: (0, 1969), 59: (0, 363), 206: (0, 1456), 49: (0, 335), 34: (0, 1589), 180: (0, 1460), 212: (0, 1466), 287: (0, 1471), 200: (0, 1474), 69: (0, 1760), 630: (0, 1478), 172: (0, 1481), 0: (1, {'@': 434}), 3: (1, {'@': 434}), 20: (1, {'@': 434}), 32: (1, {'@': 434}), 65: (1, {'@': 434}), 10: (1, {'@': 434}), 35: (1, {'@': 434}), 12: (1, {'@': 434}), 46: (1, {'@': 434}), 24: (1, {'@': 434}), 14: (1, {'@': 434}), 13: (1, {'@': 434}), 39: (1, {'@': 434}), 42: (1, {'@': 434}), 56: (1, {'@': 434}), 16: (1, {'@': 434}), 5: (1, {'@': 434}), 19: (1, {'@': 434}), 60: (1, {'@': 1124}), 57: (1, {'@': 1124})}, 1486: {112: (0, 2367)}, 1487: {57: (1, {'@': 784}), 60: (1, {'@': 784}), 126: (1, {'@': 784}), 193: (1, {'@': 784})}, 1488: {57: (1, {'@': 1254}), 60: (1, {'@': 1254}), 7: (1, {'@': 1254}), 22: (1, {'@': 1254}), 126: (1, {'@': 1254}), 34: (1, {'@': 1254})}, 1489: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 86: (0, 368), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 144: (0, 2494), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1490: {146: (0, 1860)}, 1491: {57: (1, {'@': 518}), 60: (1, {'@': 518})}, 1492: {57: (1, {'@': 1252}), 60: (1, {'@': 1252}), 7: (1, {'@': 1252}), 22: (1, {'@': 1252}), 126: (1, {'@': 1252}), 34: (1, {'@': 1252})}, 1493: {156: (0, 43), 159: (0, 42), 412: (0, 1496), 154: (0, 1501), 157: (0, 1505), 418: (0, 1507), 153: (0, 41), 152: (0, 1517), 148: (0, 48), 413: (0, 1520), 186: (0, 1525), 149: (0, 1528), 151: (0, 39), 160: (0, 1532), 414: (0, 1538), 158: (0, 1543), 191: (0, 1546), 155: (0, 1549), 150: (0, 1554), 415: (0, 1556), 416: (0, 1560), 147: (0, 28), 187: (0, 1566), 417: (0, 1571), 189: (0, 1575), 419: (0, 1579), 650: (0, 1582), 420: (0, 1587), 188: (0, 1592), 190: (0, 1596)}, 1494: {126: (0, 1856), 146: (1, {'@': 1334})}, 1495: {57: (1, {'@': 519}), 60: (1, {'@': 519})}, 1496: {60: (1, {'@': 1271}), 147: (1, {'@': 1271}), 126: (1, {'@': 1271}), 148: (1, {'@': 1271}), 149: (1, {'@': 1271}), 150: (1, {'@': 1271}), 151: (1, {'@': 1271}), 152: (1, {'@': 1271}), 153: (1, {'@': 1271}), 154: (1, {'@': 1271}), 155: (1, {'@': 1271}), 156: (1, {'@': 1271}), 157: (1, {'@': 1271}), 158: (1, {'@': 1271}), 159: (1, {'@': 1271}), 57: (1, {'@': 1271}), 160: (1, {'@': 1271})}, 1497: {126: (0, 1839), 146: (1, {'@': 1335})}, 1498: {112: (0, 2383)}, 1499: {112: (0, 1010)}, 1500: {112: (0, 2486)}, 1501: {112: (0, 1794), 60: (1, {'@': 1291}), 147: (1, {'@': 1291}), 126: (1, {'@': 1291}), 148: (1, {'@': 1291}), 149: (1, {'@': 1291}), 150: (1, {'@': 1291}), 151: (1, {'@': 1291}), 152: (1, {'@': 1291}), 153: (1, {'@': 1291}), 154: (1, {'@': 1291}), 155: (1, {'@': 1291}), 156: (1, {'@': 1291}), 157: (1, {'@': 1291}), 158: (1, {'@': 1291}), 159: (1, {'@': 1291}), 57: (1, {'@': 1291}), 160: (1, {'@': 1291})}, 1502: {60: (0, 1795)}, 1503: {112: (0, 295)}, 1504: {22: (0, 389), 206: (0, 1492), 287: (0, 1488), 7: (0, 45), 34: (0, 1589), 180: (0, 1600), 421: (0, 1603), 632: (0, 1611), 60: (1, {'@': 1248}), 57: (1, {'@': 1248})}, 1505: {112: (0, 161), 60: (1, {'@': 1282}), 147: (1, {'@': 1282}), 126: (1, {'@': 1282}), 148: (1, {'@': 1282}), 149: (1, {'@': 1282}), 150: (1, {'@': 1282}), 151: (1, {'@': 1282}), 152: (1, {'@': 1282}), 153: (1, {'@': 1282}), 154: (1, {'@': 1282}), 155: (1, {'@': 1282}), 156: (1, {'@': 1282}), 157: (1, {'@': 1282}), 158: (1, {'@': 1282}), 159: (1, {'@': 1282}), 57: (1, {'@': 1282}), 160: (1, {'@': 1282})}, 1506: {57: (1, {'@': 776}), 60: (1, {'@': 776}), 126: (1, {'@': 776}), 193: (1, {'@': 776})}, 1507: {156: (0, 43), 651: (0, 202), 418: (0, 205), 412: (0, 1496), 154: (0, 1501), 157: (0, 1505), 159: (0, 42), 153: (0, 41), 152: (0, 1517), 148: (0, 48), 413: (0, 1520), 186: (0, 1525), 149: (0, 1528), 151: (0, 39), 126: (0, 207), 160: (0, 1532), 414: (0, 1538), 158: (0, 1543), 191: (0, 1546), 155: (0, 1549), 150: (0, 1554), 415: (0, 1556), 416: (0, 1560), 147: (0, 28), 187: (0, 1566), 417: (0, 1571), 189: (0, 1575), 419: (0, 1579), 420: (0, 1587), 188: (0, 1592), 190: (0, 1596), 57: (1, {'@': 1257}), 60: (1, {'@': 1257})}, 1508: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 86: (0, 394), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 194: (0, 398), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1509: {57: (1, {'@': 1356}), 60: (1, {'@': 1356}), 126: (1, {'@': 1356}), 387: (1, {'@': 1356})}, 1510: {112: (0, 2364)}, 1511: {0: (1, {'@': 426}), 3: (1, {'@': 426}), 20: (1, {'@': 426}), 32: (1, {'@': 426}), 65: (1, {'@': 426}), 10: (1, {'@': 426}), 35: (1, {'@': 426}), 12: (1, {'@': 426}), 46: (1, {'@': 426}), 24: (1, {'@': 426}), 14: (1, {'@': 426}), 13: (1, {'@': 426}), 39: (1, {'@': 426}), 42: (1, {'@': 426}), 56: (1, {'@': 426}), 16: (1, {'@': 426}), 5: (1, {'@': 426}), 19: (1, {'@': 426}), 60: (1, {'@': 934}), 57: (1, {'@': 934})}, 1512: {374: (1, {'@': 1625}), 60: (1, {'@': 1625}), 126: (1, {'@': 1625}), 57: (1, {'@': 1625}), 306: (1, {'@': 1625})}, 1513: {57: (1, {'@': 1353}), 60: (1, {'@': 1353}), 470: (1, {'@': 1353}), 126: (1, {'@': 1353})}, 1514: {60: (1, {'@': 352}), 57: (1, {'@': 352})}, 1515: {7: (0, 45), 633: (0, 1619), 27: (0, 408), 180: (0, 1621), 28: (0, 33), 169: (0, 1623), 61: (0, 25), 165: (0, 1626), 37: (0, 1828), 426: (0, 1628), 6: (0, 20), 185: (0, 1636), 183: (0, 1638), 164: (0, 1643), 0: (1, {'@': 424}), 3: (1, {'@': 424}), 20: (1, {'@': 424}), 32: (1, {'@': 424}), 65: (1, {'@': 424}), 10: (1, {'@': 424}), 35: (1, {'@': 424}), 12: (1, {'@': 424}), 46: (1, {'@': 424}), 24: (1, {'@': 424}), 14: (1, {'@': 424}), 13: (1, {'@': 424}), 39: (1, {'@': 424}), 42: (1, {'@': 424}), 56: (1, {'@': 424}), 16: (1, {'@': 424}), 5: (1, {'@': 424}), 19: (1, {'@': 424}), 60: (1, {'@': 922}), 57: (1, {'@': 922})}, 1516: {288: (0, 1534), 290: (0, 1521), 8: (0, 1510), 52: (0, 1498), 289: (0, 2579), 292: (0, 1531), 293: (0, 1500), 126: (0, 2580), 57: (1, {'@': 742}), 60: (1, {'@': 742})}, 1517: {112: (0, 2449), 60: (1, {'@': 1288}), 147: (1, {'@': 1288}), 126: (1, {'@': 1288}), 148: (1, {'@': 1288}), 149: (1, {'@': 1288}), 150: (1, {'@': 1288}), 151: (1, {'@': 1288}), 152: (1, {'@': 1288}), 153: (1, {'@': 1288}), 154: (1, {'@': 1288}), 155: (1, {'@': 1288}), 156: (1, {'@': 1288}), 157: (1, {'@': 1288}), 158: (1, {'@': 1288}), 159: (1, {'@': 1288}), 57: (1, {'@': 1288}), 160: (1, {'@': 1288})}, 1518: {60: (1, {'@': 1347}), 57: (1, {'@': 1347})}, 1519: {60: (1, {'@': 738}), 57: (1, {'@': 738})}, 1520: {60: (1, {'@': 1261}), 147: (1, {'@': 1261}), 126: (1, {'@': 1261}), 148: (1, {'@': 1261}), 149: (1, {'@': 1261}), 150: (1, {'@': 1261}), 151: (1, {'@': 1261}), 152: (1, {'@': 1261}), 153: (1, {'@': 1261}), 154: (1, {'@': 1261}), 155: (1, {'@': 1261}), 156: (1, {'@': 1261}), 157: (1, {'@': 1261}), 158: (1, {'@': 1261}), 159: (1, {'@': 1261}), 57: (1, {'@': 1261}), 160: (1, {'@': 1261})}, 1521: {293: (1, {'@': 745}), 60: (1, {'@': 745}), 52: (1, {'@': 745}), 8: (1, {'@': 745}), 126: (1, {'@': 745}), 57: (1, {'@': 745})}, 1522: {60: (1, {'@': 1287}), 147: (1, {'@': 1287}), 126: (1, {'@': 1287}), 148: (1, {'@': 1287}), 149: (1, {'@': 1287}), 150: (1, {'@': 1287}), 151: (1, {'@': 1287}), 152: (1, {'@': 1287}), 153: (1, {'@': 1287}), 154: (1, {'@': 1287}), 155: (1, {'@': 1287}), 156: (1, {'@': 1287}), 157: (1, {'@': 1287}), 158: (1, {'@': 1287}), 159: (1, {'@': 1287}), 57: (1, {'@': 1287}), 160: (1, {'@': 1287})}, 1523: {2: (1, {'@': 831}), 60: (1, {'@': 831}), 44: (1, {'@': 831}), 61: (1, {'@': 831}), 126: (1, {'@': 831}), 63: (1, {'@': 831}), 28: (1, {'@': 831}), 33: (1, {'@': 831}), 6: (1, {'@': 831}), 52: (1, {'@': 831}), 8: (1, {'@': 831}), 53: (1, {'@': 831}), 37: (1, {'@': 831}), 71: (1, {'@': 831}), 55: (1, {'@': 831}), 57: (1, {'@': 831}), 43: (1, {'@': 831}), 1: (1, {'@': 831}), 45: (1, {'@': 831}), 47: (1, {'@': 831}), 48: (1, {'@': 831}), 4: (1, {'@': 831}), 49: (1, {'@': 831}), 50: (1, {'@': 831}), 51: (1, {'@': 831}), 7: (1, {'@': 831}), 9: (1, {'@': 831}), 11: (1, {'@': 831}), 54: (1, {'@': 831}), 15: (1, {'@': 831}), 17: (1, {'@': 831}), 18: (1, {'@': 831}), 58: (1, {'@': 831}), 59: (1, {'@': 831}), 21: (1, {'@': 831}), 22: (1, {'@': 831}), 62: (1, {'@': 831}), 23: (1, {'@': 831}), 25: (1, {'@': 831}), 26: (1, {'@': 831}), 27: (1, {'@': 831}), 29: (1, {'@': 831}), 30: (1, {'@': 831}), 31: (1, {'@': 831}), 64: (1, {'@': 831}), 66: (1, {'@': 831}), 67: (1, {'@': 831}), 34: (1, {'@': 831}), 36: (1, {'@': 831}), 68: (1, {'@': 831}), 38: (1, {'@': 831}), 69: (1, {'@': 831}), 70: (1, {'@': 831}), 40: (1, {'@': 831}), 72: (1, {'@': 831}), 41: (1, {'@': 831}), 73: (1, {'@': 831}), 74: (1, {'@': 831}), 75: (1, {'@': 831})}, 1524: {112: (0, 867)}, 1525: {60: (1, {'@': 1266}), 147: (1, {'@': 1266}), 126: (1, {'@': 1266}), 148: (1, {'@': 1266}), 149: (1, {'@': 1266}), 150: (1, {'@': 1266}), 151: (1, {'@': 1266}), 152: (1, {'@': 1266}), 153: (1, {'@': 1266}), 154: (1, {'@': 1266}), 155: (1, {'@': 1266}), 156: (1, {'@': 1266}), 157: (1, {'@': 1266}), 158: (1, {'@': 1266}), 159: (1, {'@': 1266}), 57: (1, {'@': 1266}), 160: (1, {'@': 1266})}, 1526: {22: (0, 389), 53: (0, 387), 172: (0, 1648), 7: (0, 45), 200: (0, 1652), 634: (0, 1656), 59: (0, 363), 406: (0, 1660), 49: (0, 335), 198: (0, 1667), 34: (0, 1589), 69: (0, 1760), 212: (0, 1669), 206: (0, 1673), 287: (0, 1676), 180: (0, 1678), 60: (1, {'@': 1112}), 0: (1, {'@': 433}), 3: (1, {'@': 433}), 20: (1, {'@': 433}), 32: (1, {'@': 433}), 65: (1, {'@': 433}), 10: (1, {'@': 433}), 35: (1, {'@': 433}), 12: (1, {'@': 433}), 46: (1, {'@': 433}), 24: (1, {'@': 433}), 14: (1, {'@': 433}), 13: (1, {'@': 433}), 39: (1, {'@': 433}), 42: (1, {'@': 433}), 56: (1, {'@': 433}), 16: (1, {'@': 433}), 5: (1, {'@': 433}), 19: (1, {'@': 433}), 57: (1, {'@': 1112})}, 1527: {2: (1, {'@': 843}), 60: (1, {'@': 843}), 44: (1, {'@': 843}), 61: (1, {'@': 843}), 126: (1, {'@': 843}), 63: (1, {'@': 843}), 28: (1, {'@': 843}), 33: (1, {'@': 843}), 6: (1, {'@': 843}), 52: (1, {'@': 843}), 8: (1, {'@': 843}), 53: (1, {'@': 843}), 37: (1, {'@': 843}), 71: (1, {'@': 843}), 55: (1, {'@': 843}), 57: (1, {'@': 843}), 43: (1, {'@': 843}), 1: (1, {'@': 843}), 45: (1, {'@': 843}), 47: (1, {'@': 843}), 48: (1, {'@': 843}), 4: (1, {'@': 843}), 49: (1, {'@': 843}), 50: (1, {'@': 843}), 51: (1, {'@': 843}), 7: (1, {'@': 843}), 9: (1, {'@': 843}), 11: (1, {'@': 843}), 54: (1, {'@': 843}), 15: (1, {'@': 843}), 17: (1, {'@': 843}), 18: (1, {'@': 843}), 58: (1, {'@': 843}), 59: (1, {'@': 843}), 21: (1, {'@': 843}), 22: (1, {'@': 843}), 62: (1, {'@': 843}), 23: (1, {'@': 843}), 25: (1, {'@': 843}), 26: (1, {'@': 843}), 27: (1, {'@': 843}), 29: (1, {'@': 843}), 30: (1, {'@': 843}), 31: (1, {'@': 843}), 64: (1, {'@': 843}), 66: (1, {'@': 843}), 67: (1, {'@': 843}), 34: (1, {'@': 843}), 36: (1, {'@': 843}), 68: (1, {'@': 843}), 38: (1, {'@': 843}), 69: (1, {'@': 843}), 70: (1, {'@': 843}), 40: (1, {'@': 843}), 72: (1, {'@': 843}), 41: (1, {'@': 843}), 73: (1, {'@': 843}), 74: (1, {'@': 843}), 75: (1, {'@': 843})}, 1528: {112: (0, 128), 60: (1, {'@': 1285}), 147: (1, {'@': 1285}), 126: (1, {'@': 1285}), 148: (1, {'@': 1285}), 149: (1, {'@': 1285}), 150: (1, {'@': 1285}), 151: (1, {'@': 1285}), 152: (1, {'@': 1285}), 153: (1, {'@': 1285}), 154: (1, {'@': 1285}), 155: (1, {'@': 1285}), 156: (1, {'@': 1285}), 157: (1, {'@': 1285}), 158: (1, {'@': 1285}), 159: (1, {'@': 1285}), 57: (1, {'@': 1285}), 160: (1, {'@': 1285})}, 1529: {230: (1, {'@': 721}), 60: (1, {'@': 721}), 235: (1, {'@': 721}), 240: (1, {'@': 721}), 126: (1, {'@': 721}), 231: (1, {'@': 721}), 234: (1, {'@': 721}), 57: (1, {'@': 721}), 241: (1, {'@': 721}), 243: (1, {'@': 721})}, 1530: {2: (1, {'@': 838}), 60: (1, {'@': 838}), 44: (1, {'@': 838}), 61: (1, {'@': 838}), 126: (1, {'@': 838}), 63: (1, {'@': 838}), 28: (1, {'@': 838}), 33: (1, {'@': 838}), 6: (1, {'@': 838}), 52: (1, {'@': 838}), 8: (1, {'@': 838}), 53: (1, {'@': 838}), 37: (1, {'@': 838}), 71: (1, {'@': 838}), 55: (1, {'@': 838}), 57: (1, {'@': 838}), 43: (1, {'@': 838}), 1: (1, {'@': 838}), 45: (1, {'@': 838}), 47: (1, {'@': 838}), 48: (1, {'@': 838}), 4: (1, {'@': 838}), 49: (1, {'@': 838}), 50: (1, {'@': 838}), 51: (1, {'@': 838}), 7: (1, {'@': 838}), 9: (1, {'@': 838}), 11: (1, {'@': 838}), 54: (1, {'@': 838}), 15: (1, {'@': 838}), 17: (1, {'@': 838}), 18: (1, {'@': 838}), 58: (1, {'@': 838}), 59: (1, {'@': 838}), 21: (1, {'@': 838}), 22: (1, {'@': 838}), 62: (1, {'@': 838}), 23: (1, {'@': 838}), 25: (1, {'@': 838}), 26: (1, {'@': 838}), 27: (1, {'@': 838}), 29: (1, {'@': 838}), 30: (1, {'@': 838}), 31: (1, {'@': 838}), 64: (1, {'@': 838}), 66: (1, {'@': 838}), 67: (1, {'@': 838}), 34: (1, {'@': 838}), 36: (1, {'@': 838}), 68: (1, {'@': 838}), 38: (1, {'@': 838}), 69: (1, {'@': 838}), 70: (1, {'@': 838}), 40: (1, {'@': 838}), 72: (1, {'@': 838}), 41: (1, {'@': 838}), 73: (1, {'@': 838}), 74: (1, {'@': 838}), 75: (1, {'@': 838})}, 1531: {293: (1, {'@': 744}), 60: (1, {'@': 744}), 52: (1, {'@': 744}), 8: (1, {'@': 744}), 126: (1, {'@': 744}), 57: (1, {'@': 744})}, 1532: {112: (0, 127), 60: (1, {'@': 1279}), 147: (1, {'@': 1279}), 126: (1, {'@': 1279}), 148: (1, {'@': 1279}), 149: (1, {'@': 1279}), 150: (1, {'@': 1279}), 151: (1, {'@': 1279}), 152: (1, {'@': 1279}), 153: (1, {'@': 1279}), 154: (1, {'@': 1279}), 155: (1, {'@': 1279}), 156: (1, {'@': 1279}), 157: (1, {'@': 1279}), 158: (1, {'@': 1279}), 159: (1, {'@': 1279}), 57: (1, {'@': 1279}), 160: (1, {'@': 1279})}, 1533: {60: (1, {'@': 346}), 57: (1, {'@': 346})}, 1534: {293: (1, {'@': 743}), 60: (1, {'@': 743}), 52: (1, {'@': 743}), 8: (1, {'@': 743}), 126: (1, {'@': 743}), 57: (1, {'@': 743})}, 1535: {2: (1, {'@': 829}), 60: (1, {'@': 829}), 44: (1, {'@': 829}), 61: (1, {'@': 829}), 126: (1, {'@': 829}), 63: (1, {'@': 829}), 28: (1, {'@': 829}), 33: (1, {'@': 829}), 6: (1, {'@': 829}), 52: (1, {'@': 829}), 8: (1, {'@': 829}), 53: (1, {'@': 829}), 37: (1, {'@': 829}), 71: (1, {'@': 829}), 55: (1, {'@': 829}), 57: (1, {'@': 829}), 43: (1, {'@': 829}), 1: (1, {'@': 829}), 45: (1, {'@': 829}), 47: (1, {'@': 829}), 48: (1, {'@': 829}), 4: (1, {'@': 829}), 49: (1, {'@': 829}), 50: (1, {'@': 829}), 51: (1, {'@': 829}), 7: (1, {'@': 829}), 9: (1, {'@': 829}), 11: (1, {'@': 829}), 54: (1, {'@': 829}), 15: (1, {'@': 829}), 17: (1, {'@': 829}), 18: (1, {'@': 829}), 58: (1, {'@': 829}), 59: (1, {'@': 829}), 21: (1, {'@': 829}), 22: (1, {'@': 829}), 62: (1, {'@': 829}), 23: (1, {'@': 829}), 25: (1, {'@': 829}), 26: (1, {'@': 829}), 27: (1, {'@': 829}), 29: (1, {'@': 829}), 30: (1, {'@': 829}), 31: (1, {'@': 829}), 64: (1, {'@': 829}), 66: (1, {'@': 829}), 67: (1, {'@': 829}), 34: (1, {'@': 829}), 36: (1, {'@': 829}), 68: (1, {'@': 829}), 38: (1, {'@': 829}), 69: (1, {'@': 829}), 70: (1, {'@': 829}), 40: (1, {'@': 829}), 72: (1, {'@': 829}), 41: (1, {'@': 829}), 73: (1, {'@': 829}), 74: (1, {'@': 829}), 75: (1, {'@': 829})}, 1536: {60: (1, {'@': 931}), 57: (1, {'@': 931})}, 1537: {112: (0, 2353)}, 1538: {60: (1, {'@': 1258}), 147: (1, {'@': 1258}), 126: (1, {'@': 1258}), 148: (1, {'@': 1258}), 149: (1, {'@': 1258}), 150: (1, {'@': 1258}), 151: (1, {'@': 1258}), 152: (1, {'@': 1258}), 153: (1, {'@': 1258}), 154: (1, {'@': 1258}), 155: (1, {'@': 1258}), 156: (1, {'@': 1258}), 157: (1, {'@': 1258}), 158: (1, {'@': 1258}), 159: (1, {'@': 1258}), 57: (1, {'@': 1258}), 160: (1, {'@': 1258})}, 1539: {60: (1, {'@': 332}), 57: (1, {'@': 332})}, 1540: {43: (1, {'@': 898}), 1: (1, {'@': 898}), 2: (1, {'@': 898}), 44: (1, {'@': 898}), 45: (1, {'@': 898}), 47: (1, {'@': 898}), 48: (1, {'@': 898}), 4: (1, {'@': 898}), 49: (1, {'@': 898}), 50: (1, {'@': 898}), 51: (1, {'@': 898}), 6: (1, {'@': 898}), 52: (1, {'@': 898}), 8: (1, {'@': 898}), 7: (1, {'@': 898}), 9: (1, {'@': 898}), 53: (1, {'@': 898}), 11: (1, {'@': 898}), 54: (1, {'@': 898}), 55: (1, {'@': 898}), 15: (1, {'@': 898}), 17: (1, {'@': 898}), 57: (1, {'@': 898}), 18: (1, {'@': 898}), 58: (1, {'@': 898}), 59: (1, {'@': 898}), 21: (1, {'@': 898}), 22: (1, {'@': 898}), 60: (1, {'@': 898}), 61: (1, {'@': 898}), 126: (1, {'@': 898}), 62: (1, {'@': 898}), 23: (1, {'@': 898}), 25: (1, {'@': 898}), 26: (1, {'@': 898}), 63: (1, {'@': 898}), 27: (1, {'@': 898}), 28: (1, {'@': 898}), 29: (1, {'@': 898}), 30: (1, {'@': 898}), 31: (1, {'@': 898}), 33: (1, {'@': 898}), 64: (1, {'@': 898}), 66: (1, {'@': 898}), 67: (1, {'@': 898}), 34: (1, {'@': 898}), 36: (1, {'@': 898}), 37: (1, {'@': 898}), 68: (1, {'@': 898}), 38: (1, {'@': 898}), 69: (1, {'@': 898}), 70: (1, {'@': 898}), 71: (1, {'@': 898}), 40: (1, {'@': 898}), 72: (1, {'@': 898}), 41: (1, {'@': 898}), 73: (1, {'@': 898}), 74: (1, {'@': 898}), 75: (1, {'@': 898})}, 1541: {167: (0, 1614), 165: (0, 1681), 411: (0, 1686), 164: (0, 1694), 27: (0, 408), 51: (0, 1695), 26: (0, 1797), 163: (0, 1698), 38: (0, 1811), 61: (0, 25), 410: (0, 1703), 169: (0, 1708), 37: (0, 1828), 635: (0, 1713), 0: (1, {'@': 429}), 3: (1, {'@': 429}), 20: (1, {'@': 429}), 32: (1, {'@': 429}), 65: (1, {'@': 429}), 10: (1, {'@': 429}), 35: (1, {'@': 429}), 12: (1, {'@': 429}), 46: (1, {'@': 429}), 24: (1, {'@': 429}), 14: (1, {'@': 429}), 13: (1, {'@': 429}), 39: (1, {'@': 429}), 42: (1, {'@': 429}), 56: (1, {'@': 429}), 16: (1, {'@': 429}), 5: (1, {'@': 429}), 19: (1, {'@': 429}), 60: (1, {'@': 989}), 57: (1, {'@': 989})}, 1542: {43: (1, {'@': 1048}), 44: (1, {'@': 1048}), 45: (1, {'@': 1048}), 6: (1, {'@': 1048}), 53: (1, {'@': 1048}), 54: (1, {'@': 1048}), 57: (1, {'@': 1048}), 18: (1, {'@': 1048}), 60: (1, {'@': 1048}), 21: (1, {'@': 1048}), 126: (1, {'@': 1048}), 61: (1, {'@': 1048}), 27: (1, {'@': 1048}), 28: (1, {'@': 1048}), 33: (1, {'@': 1048}), 64: (1, {'@': 1048}), 34: (1, {'@': 1048}), 37: (1, {'@': 1048}), 38: (1, {'@': 1048}), 69: (1, {'@': 1048}), 40: (1, {'@': 1048}), 74: (1, {'@': 1048}), 41: (1, {'@': 1048}), 75: (1, {'@': 1048})}, 1543: {112: (0, 163), 60: (1, {'@': 1299}), 147: (1, {'@': 1299}), 126: (1, {'@': 1299}), 148: (1, {'@': 1299}), 149: (1, {'@': 1299}), 150: (1, {'@': 1299}), 151: (1, {'@': 1299}), 152: (1, {'@': 1299}), 153: (1, {'@': 1299}), 154: (1, {'@': 1299}), 155: (1, {'@': 1299}), 156: (1, {'@': 1299}), 157: (1, {'@': 1299}), 158: (1, {'@': 1299}), 159: (1, {'@': 1299}), 57: (1, {'@': 1299}), 160: (1, {'@': 1299})}, 1544: {144: (0, 2316), 145: (0, 1877)}, 1545: {43: (1, {'@': 1042}), 44: (1, {'@': 1042}), 45: (1, {'@': 1042}), 6: (1, {'@': 1042}), 53: (1, {'@': 1042}), 54: (1, {'@': 1042}), 57: (1, {'@': 1042}), 18: (1, {'@': 1042}), 60: (1, {'@': 1042}), 21: (1, {'@': 1042}), 126: (1, {'@': 1042}), 61: (1, {'@': 1042}), 27: (1, {'@': 1042}), 28: (1, {'@': 1042}), 33: (1, {'@': 1042}), 64: (1, {'@': 1042}), 34: (1, {'@': 1042}), 37: (1, {'@': 1042}), 38: (1, {'@': 1042}), 69: (1, {'@': 1042}), 40: (1, {'@': 1042}), 74: (1, {'@': 1042}), 41: (1, {'@': 1042}), 75: (1, {'@': 1042})}, 1546: {60: (1, {'@': 1270}), 147: (1, {'@': 1270}), 126: (1, {'@': 1270}), 148: (1, {'@': 1270}), 149: (1, {'@': 1270}), 150: (1, {'@': 1270}), 151: (1, {'@': 1270}), 152: (1, {'@': 1270}), 153: (1, {'@': 1270}), 154: (1, {'@': 1270}), 155: (1, {'@': 1270}), 156: (1, {'@': 1270}), 157: (1, {'@': 1270}), 158: (1, {'@': 1270}), 159: (1, {'@': 1270}), 57: (1, {'@': 1270}), 160: (1, {'@': 1270})}, 1547: {60: (1, {'@': 335}), 57: (1, {'@': 335})}, 1548: {112: (0, 2349)}, 1549: {112: (0, 190)}, 1550: {112: (0, 1762)}, 1551: {126: (1, {'@': 1568}), 146: (1, {'@': 1568})}, 1552: {22: (0, 389), 53: (0, 387), 7: (0, 45), 68: (0, 1724), 70: (0, 1727), 446: (0, 1731), 652: (0, 1739), 444: (0, 1742), 49: (0, 335), 34: (0, 1589), 206: (0, 1747), 198: (0, 1751), 445: (0, 1754), 69: (0, 1760), 172: (0, 1757), 180: (0, 1761), 287: (0, 1764), 200: (0, 1766), 0: (1, {'@': 436}), 3: (1, {'@': 436}), 20: (1, {'@': 436}), 32: (1, {'@': 436}), 65: (1, {'@': 436}), 10: (1, {'@': 436}), 35: (1, {'@': 436}), 12: (1, {'@': 436}), 46: (1, {'@': 436}), 24: (1, {'@': 436}), 14: (1, {'@': 436}), 13: (1, {'@': 436}), 39: (1, {'@': 436}), 42: (1, {'@': 436}), 56: (1, {'@': 436}), 16: (1, {'@': 436}), 5: (1, {'@': 436}), 19: (1, {'@': 436}), 60: (1, {'@': 1182}), 57: (1, {'@': 1182})}, 1553: {43: (1, {'@': 1045}), 44: (1, {'@': 1045}), 45: (1, {'@': 1045}), 6: (1, {'@': 1045}), 53: (1, {'@': 1045}), 54: (1, {'@': 1045}), 57: (1, {'@': 1045}), 18: (1, {'@': 1045}), 60: (1, {'@': 1045}), 21: (1, {'@': 1045}), 126: (1, {'@': 1045}), 61: (1, {'@': 1045}), 27: (1, {'@': 1045}), 28: (1, {'@': 1045}), 33: (1, {'@': 1045}), 64: (1, {'@': 1045}), 34: (1, {'@': 1045}), 37: (1, {'@': 1045}), 38: (1, {'@': 1045}), 69: (1, {'@': 1045}), 40: (1, {'@': 1045}), 74: (1, {'@': 1045}), 41: (1, {'@': 1045}), 75: (1, {'@': 1045})}, 1554: {112: (0, 158)}, 1555: {53: (0, 387), 18: (0, 1581), 164: (0, 1635), 33: (0, 383), 74: (0, 1616), 64: (0, 1537), 44: (0, 358), 41: (0, 372), 21: (0, 366), 27: (0, 408), 172: (0, 1620), 286: (0, 1640), 280: (0, 1542), 169: (0, 1657), 283: (0, 1585), 75: (0, 341), 38: (0, 1811), 167: (0, 1625), 282: (0, 2327), 281: (0, 1545), 28: (0, 33), 126: (0, 2342), 43: (0, 1548), 61: (0, 25), 34: (0, 1589), 284: (0, 1594), 165: (0, 1553), 54: (0, 1598), 37: (0, 1828), 40: (0, 1756), 69: (0, 1760), 45: (0, 1833), 204: (0, 1565), 6: (0, 20), 185: (0, 1569), 207: (0, 1646), 200: (0, 1627), 211: (0, 1602), 208: (0, 1573), 183: (0, 1607), 201: (0, 1650), 287: (0, 1654), 168: (0, 1577), 210: (0, 1631), 57: (1, {'@': 1029}), 60: (1, {'@': 1029})}, 1556: {60: (1, {'@': 1260}), 147: (1, {'@': 1260}), 126: (1, {'@': 1260}), 148: (1, {'@': 1260}), 149: (1, {'@': 1260}), 150: (1, {'@': 1260}), 151: (1, {'@': 1260}), 152: (1, {'@': 1260}), 153: (1, {'@': 1260}), 154: (1, {'@': 1260}), 155: (1, {'@': 1260}), 156: (1, {'@': 1260}), 157: (1, {'@': 1260}), 158: (1, {'@': 1260}), 159: (1, {'@': 1260}), 57: (1, {'@': 1260}), 160: (1, {'@': 1260})}, 1557: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 194: (0, 403), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 86: (0, 404), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1558: {144: (0, 1324), 560: (0, 1800)}, 1559: {60: (1, {'@': 342}), 57: (1, {'@': 342})}, 1560: {60: (1, {'@': 1262}), 147: (1, {'@': 1262}), 126: (1, {'@': 1262}), 148: (1, {'@': 1262}), 149: (1, {'@': 1262}), 150: (1, {'@': 1262}), 151: (1, {'@': 1262}), 152: (1, {'@': 1262}), 153: (1, {'@': 1262}), 154: (1, {'@': 1262}), 155: (1, {'@': 1262}), 156: (1, {'@': 1262}), 157: (1, {'@': 1262}), 158: (1, {'@': 1262}), 159: (1, {'@': 1262}), 57: (1, {'@': 1262}), 160: (1, {'@': 1262})}, 1561: {86: (0, 410), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 194: (0, 412), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 1562: {146: (0, 1878)}, 1563: {112: (0, 309)}, 1564: {60: (1, {'@': 344}), 57: (1, {'@': 344})}, 1565: {43: (1, {'@': 1032}), 44: (1, {'@': 1032}), 45: (1, {'@': 1032}), 6: (1, {'@': 1032}), 53: (1, {'@': 1032}), 54: (1, {'@': 1032}), 57: (1, {'@': 1032}), 18: (1, {'@': 1032}), 60: (1, {'@': 1032}), 21: (1, {'@': 1032}), 126: (1, {'@': 1032}), 61: (1, {'@': 1032}), 27: (1, {'@': 1032}), 28: (1, {'@': 1032}), 33: (1, {'@': 1032}), 64: (1, {'@': 1032}), 34: (1, {'@': 1032}), 37: (1, {'@': 1032}), 38: (1, {'@': 1032}), 69: (1, {'@': 1032}), 40: (1, {'@': 1032}), 74: (1, {'@': 1032}), 41: (1, {'@': 1032}), 75: (1, {'@': 1032})}, 1566: {60: (1, {'@': 1269}), 147: (1, {'@': 1269}), 126: (1, {'@': 1269}), 148: (1, {'@': 1269}), 149: (1, {'@': 1269}), 150: (1, {'@': 1269}), 151: (1, {'@': 1269}), 152: (1, {'@': 1269}), 153: (1, {'@': 1269}), 154: (1, {'@': 1269}), 155: (1, {'@': 1269}), 156: (1, {'@': 1269}), 157: (1, {'@': 1269}), 158: (1, {'@': 1269}), 159: (1, {'@': 1269}), 57: (1, {'@': 1269}), 160: (1, {'@': 1269})}, 1567: {126: (1, {'@': 1737}), 60: (1, {'@': 1737})}, 1568: {60: (1, {'@': 306}), 57: (1, {'@': 306})}, 1569: {43: (1, {'@': 1030}), 44: (1, {'@': 1030}), 45: (1, {'@': 1030}), 6: (1, {'@': 1030}), 53: (1, {'@': 1030}), 54: (1, {'@': 1030}), 57: (1, {'@': 1030}), 18: (1, {'@': 1030}), 60: (1, {'@': 1030}), 21: (1, {'@': 1030}), 126: (1, {'@': 1030}), 61: (1, {'@': 1030}), 27: (1, {'@': 1030}), 28: (1, {'@': 1030}), 33: (1, {'@': 1030}), 64: (1, {'@': 1030}), 34: (1, {'@': 1030}), 37: (1, {'@': 1030}), 38: (1, {'@': 1030}), 69: (1, {'@': 1030}), 40: (1, {'@': 1030}), 74: (1, {'@': 1030}), 41: (1, {'@': 1030}), 75: (1, {'@': 1030})}, 1570: {112: (0, 1734)}, 1571: {60: (1, {'@': 1263}), 147: (1, {'@': 1263}), 126: (1, {'@': 1263}), 148: (1, {'@': 1263}), 149: (1, {'@': 1263}), 150: (1, {'@': 1263}), 151: (1, {'@': 1263}), 152: (1, {'@': 1263}), 153: (1, {'@': 1263}), 154: (1, {'@': 1263}), 155: (1, {'@': 1263}), 156: (1, {'@': 1263}), 157: (1, {'@': 1263}), 158: (1, {'@': 1263}), 159: (1, {'@': 1263}), 57: (1, {'@': 1263}), 160: (1, {'@': 1263})}, 1572: {637: (0, 1772), 193: (0, 53), 638: (0, 1775), 192: (0, 1777)}, 1573: {43: (1, {'@': 1037}), 44: (1, {'@': 1037}), 45: (1, {'@': 1037}), 6: (1, {'@': 1037}), 53: (1, {'@': 1037}), 54: (1, {'@': 1037}), 57: (1, {'@': 1037}), 18: (1, {'@': 1037}), 60: (1, {'@': 1037}), 21: (1, {'@': 1037}), 126: (1, {'@': 1037}), 61: (1, {'@': 1037}), 27: (1, {'@': 1037}), 28: (1, {'@': 1037}), 33: (1, {'@': 1037}), 64: (1, {'@': 1037}), 34: (1, {'@': 1037}), 37: (1, {'@': 1037}), 38: (1, {'@': 1037}), 69: (1, {'@': 1037}), 40: (1, {'@': 1037}), 74: (1, {'@': 1037}), 41: (1, {'@': 1037}), 75: (1, {'@': 1037})}, 1574: {60: (1, {'@': 1415})}, 1575: {60: (1, {'@': 1267}), 147: (1, {'@': 1267}), 126: (1, {'@': 1267}), 148: (1, {'@': 1267}), 149: (1, {'@': 1267}), 150: (1, {'@': 1267}), 151: (1, {'@': 1267}), 152: (1, {'@': 1267}), 153: (1, {'@': 1267}), 154: (1, {'@': 1267}), 155: (1, {'@': 1267}), 156: (1, {'@': 1267}), 157: (1, {'@': 1267}), 158: (1, {'@': 1267}), 159: (1, {'@': 1267}), 57: (1, {'@': 1267}), 160: (1, {'@': 1267})}, 1576: {126: (1, {'@': 1643}), 60: (1, {'@': 1643})}, 1577: {43: (1, {'@': 1038}), 44: (1, {'@': 1038}), 45: (1, {'@': 1038}), 6: (1, {'@': 1038}), 53: (1, {'@': 1038}), 54: (1, {'@': 1038}), 57: (1, {'@': 1038}), 18: (1, {'@': 1038}), 60: (1, {'@': 1038}), 21: (1, {'@': 1038}), 126: (1, {'@': 1038}), 61: (1, {'@': 1038}), 27: (1, {'@': 1038}), 28: (1, {'@': 1038}), 33: (1, {'@': 1038}), 64: (1, {'@': 1038}), 34: (1, {'@': 1038}), 37: (1, {'@': 1038}), 38: (1, {'@': 1038}), 69: (1, {'@': 1038}), 40: (1, {'@': 1038}), 74: (1, {'@': 1038}), 41: (1, {'@': 1038}), 75: (1, {'@': 1038})}, 1578: {146: (0, 922)}, 1579: {60: (1, {'@': 1264}), 147: (1, {'@': 1264}), 126: (1, {'@': 1264}), 148: (1, {'@': 1264}), 149: (1, {'@': 1264}), 150: (1, {'@': 1264}), 151: (1, {'@': 1264}), 152: (1, {'@': 1264}), 153: (1, {'@': 1264}), 154: (1, {'@': 1264}), 155: (1, {'@': 1264}), 156: (1, {'@': 1264}), 157: (1, {'@': 1264}), 158: (1, {'@': 1264}), 159: (1, {'@': 1264}), 57: (1, {'@': 1264}), 160: (1, {'@': 1264})}, 1580: {60: (0, 1826)}, 1581: {112: (0, 2415), 43: (1, {'@': 1487}), 60: (1, {'@': 1487}), 21: (1, {'@': 1487}), 44: (1, {'@': 1487}), 126: (1, {'@': 1487}), 61: (1, {'@': 1487}), 45: (1, {'@': 1487}), 27: (1, {'@': 1487}), 28: (1, {'@': 1487}), 6: (1, {'@': 1487}), 33: (1, {'@': 1487}), 64: (1, {'@': 1487}), 34: (1, {'@': 1487}), 53: (1, {'@': 1487}), 37: (1, {'@': 1487}), 54: (1, {'@': 1487}), 38: (1, {'@': 1487}), 69: (1, {'@': 1487}), 40: (1, {'@': 1487}), 74: (1, {'@': 1487}), 41: (1, {'@': 1487}), 75: (1, {'@': 1487}), 57: (1, {'@': 1487}), 18: (1, {'@': 1487}), 22: (1, {'@': 1487}), 62: (1, {'@': 1487}), 73: (1, {'@': 1487}), 1: (1, {'@': 1487}), 2: (1, {'@': 1487}), 47: (1, {'@': 1487}), 48: (1, {'@': 1487}), 4: (1, {'@': 1487}), 49: (1, {'@': 1487}), 50: (1, {'@': 1487}), 51: (1, {'@': 1487}), 52: (1, {'@': 1487}), 8: (1, {'@': 1487}), 7: (1, {'@': 1487}), 9: (1, {'@': 1487}), 11: (1, {'@': 1487}), 55: (1, {'@': 1487}), 15: (1, {'@': 1487}), 17: (1, {'@': 1487}), 58: (1, {'@': 1487}), 59: (1, {'@': 1487}), 23: (1, {'@': 1487}), 25: (1, {'@': 1487}), 26: (1, {'@': 1487}), 63: (1, {'@': 1487}), 29: (1, {'@': 1487}), 30: (1, {'@': 1487}), 31: (1, {'@': 1487}), 66: (1, {'@': 1487}), 67: (1, {'@': 1487}), 36: (1, {'@': 1487}), 68: (1, {'@': 1487}), 70: (1, {'@': 1487}), 71: (1, {'@': 1487}), 72: (1, {'@': 1487})}, 1582: {60: (1, {'@': 1255}), 57: (1, {'@': 1255})}, 1583: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 194: (0, 1283), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 86: (0, 1298), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1584: {60: (0, 1873)}, 1585: {43: (1, {'@': 1050}), 44: (1, {'@': 1050}), 45: (1, {'@': 1050}), 6: (1, {'@': 1050}), 53: (1, {'@': 1050}), 54: (1, {'@': 1050}), 57: (1, {'@': 1050}), 18: (1, {'@': 1050}), 60: (1, {'@': 1050}), 21: (1, {'@': 1050}), 126: (1, {'@': 1050}), 61: (1, {'@': 1050}), 27: (1, {'@': 1050}), 28: (1, {'@': 1050}), 33: (1, {'@': 1050}), 64: (1, {'@': 1050}), 34: (1, {'@': 1050}), 37: (1, {'@': 1050}), 38: (1, {'@': 1050}), 69: (1, {'@': 1050}), 40: (1, {'@': 1050}), 74: (1, {'@': 1050}), 41: (1, {'@': 1050}), 75: (1, {'@': 1050})}, 1586: {60: (1, {'@': 356}), 57: (1, {'@': 356})}, 1587: {60: (1, {'@': 1259}), 147: (1, {'@': 1259}), 126: (1, {'@': 1259}), 148: (1, {'@': 1259}), 149: (1, {'@': 1259}), 150: (1, {'@': 1259}), 151: (1, {'@': 1259}), 152: (1, {'@': 1259}), 153: (1, {'@': 1259}), 154: (1, {'@': 1259}), 155: (1, {'@': 1259}), 156: (1, {'@': 1259}), 157: (1, {'@': 1259}), 158: (1, {'@': 1259}), 159: (1, {'@': 1259}), 57: (1, {'@': 1259}), 160: (1, {'@': 1259})}, 1588: {60: (1, {'@': 329}), 57: (1, {'@': 329})}, 1589: {112: (0, 58), 43: (1, {'@': 1502}), 60: (1, {'@': 1502}), 21: (1, {'@': 1502}), 44: (1, {'@': 1502}), 126: (1, {'@': 1502}), 61: (1, {'@': 1502}), 45: (1, {'@': 1502}), 27: (1, {'@': 1502}), 28: (1, {'@': 1502}), 6: (1, {'@': 1502}), 33: (1, {'@': 1502}), 64: (1, {'@': 1502}), 34: (1, {'@': 1502}), 53: (1, {'@': 1502}), 37: (1, {'@': 1502}), 54: (1, {'@': 1502}), 38: (1, {'@': 1502}), 69: (1, {'@': 1502}), 40: (1, {'@': 1502}), 74: (1, {'@': 1502}), 41: (1, {'@': 1502}), 75: (1, {'@': 1502}), 57: (1, {'@': 1502}), 18: (1, {'@': 1502}), 22: (1, {'@': 1502}), 62: (1, {'@': 1502}), 73: (1, {'@': 1502}), 1: (1, {'@': 1502}), 2: (1, {'@': 1502}), 47: (1, {'@': 1502}), 48: (1, {'@': 1502}), 4: (1, {'@': 1502}), 49: (1, {'@': 1502}), 50: (1, {'@': 1502}), 51: (1, {'@': 1502}), 52: (1, {'@': 1502}), 8: (1, {'@': 1502}), 7: (1, {'@': 1502}), 9: (1, {'@': 1502}), 11: (1, {'@': 1502}), 55: (1, {'@': 1502}), 15: (1, {'@': 1502}), 17: (1, {'@': 1502}), 58: (1, {'@': 1502}), 59: (1, {'@': 1502}), 23: (1, {'@': 1502}), 25: (1, {'@': 1502}), 26: (1, {'@': 1502}), 63: (1, {'@': 1502}), 29: (1, {'@': 1502}), 30: (1, {'@': 1502}), 31: (1, {'@': 1502}), 66: (1, {'@': 1502}), 67: (1, {'@': 1502}), 36: (1, {'@': 1502}), 68: (1, {'@': 1502}), 70: (1, {'@': 1502}), 71: (1, {'@': 1502}), 72: (1, {'@': 1502})}, 1590: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 86: (0, 1437), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 594: (0, 1890), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 312: (0, 1417), 592: (0, 1422), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 596: (0, 1440), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 111: (0, 821), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 313: (0, 2377), 65: (0, 834), 42: (0, 858), 119: (0, 836), 106: (0, 838), 591: (0, 1420), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 595: (0, 1436), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1591: {112: (0, 1718)}, 1592: {60: (1, {'@': 1265}), 147: (1, {'@': 1265}), 126: (1, {'@': 1265}), 148: (1, {'@': 1265}), 149: (1, {'@': 1265}), 150: (1, {'@': 1265}), 151: (1, {'@': 1265}), 152: (1, {'@': 1265}), 153: (1, {'@': 1265}), 154: (1, {'@': 1265}), 155: (1, {'@': 1265}), 156: (1, {'@': 1265}), 157: (1, {'@': 1265}), 158: (1, {'@': 1265}), 159: (1, {'@': 1265}), 57: (1, {'@': 1265}), 160: (1, {'@': 1265})}, 1593: {60: (1, {'@': 331}), 57: (1, {'@': 331})}, 1594: {43: (1, {'@': 1035}), 44: (1, {'@': 1035}), 45: (1, {'@': 1035}), 6: (1, {'@': 1035}), 53: (1, {'@': 1035}), 54: (1, {'@': 1035}), 57: (1, {'@': 1035}), 18: (1, {'@': 1035}), 60: (1, {'@': 1035}), 21: (1, {'@': 1035}), 126: (1, {'@': 1035}), 61: (1, {'@': 1035}), 27: (1, {'@': 1035}), 28: (1, {'@': 1035}), 33: (1, {'@': 1035}), 64: (1, {'@': 1035}), 34: (1, {'@': 1035}), 37: (1, {'@': 1035}), 38: (1, {'@': 1035}), 69: (1, {'@': 1035}), 40: (1, {'@': 1035}), 74: (1, {'@': 1035}), 41: (1, {'@': 1035}), 75: (1, {'@': 1035})}, 1595: {60: (1, {'@': 351}), 57: (1, {'@': 351})}, 1596: {60: (1, {'@': 1268}), 147: (1, {'@': 1268}), 126: (1, {'@': 1268}), 148: (1, {'@': 1268}), 149: (1, {'@': 1268}), 150: (1, {'@': 1268}), 151: (1, {'@': 1268}), 152: (1, {'@': 1268}), 153: (1, {'@': 1268}), 154: (1, {'@': 1268}), 155: (1, {'@': 1268}), 156: (1, {'@': 1268}), 157: (1, {'@': 1268}), 158: (1, {'@': 1268}), 159: (1, {'@': 1268}), 57: (1, {'@': 1268}), 160: (1, {'@': 1268})}, 1597: {60: (1, {'@': 326}), 57: (1, {'@': 326})}, 1598: {112: (0, 2388)}, 1599: {60: (1, {'@': 347}), 57: (1, {'@': 347})}, 1600: {57: (1, {'@': 1253}), 60: (1, {'@': 1253}), 7: (1, {'@': 1253}), 22: (1, {'@': 1253}), 126: (1, {'@': 1253}), 34: (1, {'@': 1253})}, 1601: {60: (1, {'@': 336}), 57: (1, {'@': 336})}, 1602: {43: (1, {'@': 1040}), 44: (1, {'@': 1040}), 45: (1, {'@': 1040}), 6: (1, {'@': 1040}), 53: (1, {'@': 1040}), 54: (1, {'@': 1040}), 57: (1, {'@': 1040}), 18: (1, {'@': 1040}), 60: (1, {'@': 1040}), 21: (1, {'@': 1040}), 126: (1, {'@': 1040}), 61: (1, {'@': 1040}), 27: (1, {'@': 1040}), 28: (1, {'@': 1040}), 33: (1, {'@': 1040}), 64: (1, {'@': 1040}), 34: (1, {'@': 1040}), 37: (1, {'@': 1040}), 38: (1, {'@': 1040}), 69: (1, {'@': 1040}), 40: (1, {'@': 1040}), 74: (1, {'@': 1040}), 41: (1, {'@': 1040}), 75: (1, {'@': 1040})}, 1603: {22: (0, 389), 206: (0, 1492), 126: (0, 228), 287: (0, 1488), 7: (0, 45), 34: (0, 1589), 180: (0, 1600), 421: (0, 230), 60: (1, {'@': 1251}), 57: (1, {'@': 1251})}, 1604: {60: (0, 1895)}, 1605: {401: (0, 1785), 192: (0, 1791), 400: (0, 1799), 193: (0, 53), 653: (0, 1801), 60: (1, {'@': 787}), 57: (1, {'@': 787})}, 1606: {60: (0, 1892)}, 1607: {43: (1, {'@': 1034}), 44: (1, {'@': 1034}), 45: (1, {'@': 1034}), 6: (1, {'@': 1034}), 53: (1, {'@': 1034}), 54: (1, {'@': 1034}), 57: (1, {'@': 1034}), 18: (1, {'@': 1034}), 60: (1, {'@': 1034}), 21: (1, {'@': 1034}), 126: (1, {'@': 1034}), 61: (1, {'@': 1034}), 27: (1, {'@': 1034}), 28: (1, {'@': 1034}), 33: (1, {'@': 1034}), 64: (1, {'@': 1034}), 34: (1, {'@': 1034}), 37: (1, {'@': 1034}), 38: (1, {'@': 1034}), 69: (1, {'@': 1034}), 40: (1, {'@': 1034}), 74: (1, {'@': 1034}), 41: (1, {'@': 1034}), 75: (1, {'@': 1034})}, 1608: {146: (0, 740)}, 1609: {126: (1, {'@': 1449})}, 1610: {60: (1, {'@': 1025}), 57: (1, {'@': 1025})}, 1611: {60: (1, {'@': 1247}), 57: (1, {'@': 1247})}, 1612: {126: (1, {'@': 1454})}, 1613: {60: (1, {'@': 337}), 57: (1, {'@': 337})}, 1614: {57: (1, {'@': 994}), 60: (1, {'@': 994}), 126: (1, {'@': 994}), 61: (1, {'@': 994}), 37: (1, {'@': 994}), 38: (1, {'@': 994}), 26: (1, {'@': 994}), 27: (1, {'@': 994}), 51: (1, {'@': 994})}, 1615: {60: (1, {'@': 313}), 57: (1, {'@': 313})}, 1616: {112: (0, 2404)}, 1617: {126: (1, {'@': 1453})}, 1618: {115: (0, 44), 77: (0, 17), 108: (0, 400), 219: (0, 1780), 12: (0, 1939), 109: (0, 1830), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 1957), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 5: (0, 787), 91: (0, 863), 96: (0, 789), 82: (0, 791), 98: (0, 793), 124: (0, 864), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 1965), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 86: (0, 1804)}, 1619: {60: (1, {'@': 921}), 57: (1, {'@': 921})}, 1620: {43: (1, {'@': 1036}), 44: (1, {'@': 1036}), 45: (1, {'@': 1036}), 6: (1, {'@': 1036}), 53: (1, {'@': 1036}), 54: (1, {'@': 1036}), 57: (1, {'@': 1036}), 18: (1, {'@': 1036}), 60: (1, {'@': 1036}), 21: (1, {'@': 1036}), 126: (1, {'@': 1036}), 61: (1, {'@': 1036}), 27: (1, {'@': 1036}), 28: (1, {'@': 1036}), 33: (1, {'@': 1036}), 64: (1, {'@': 1036}), 34: (1, {'@': 1036}), 37: (1, {'@': 1036}), 38: (1, {'@': 1036}), 69: (1, {'@': 1036}), 40: (1, {'@': 1036}), 74: (1, {'@': 1036}), 41: (1, {'@': 1036}), 75: (1, {'@': 1036})}, 1621: {6: (1, {'@': 928}), 60: (1, {'@': 928}), 7: (1, {'@': 928}), 61: (1, {'@': 928}), 126: (1, {'@': 928}), 37: (1, {'@': 928}), 27: (1, {'@': 928}), 28: (1, {'@': 928}), 57: (1, {'@': 928})}, 1622: {126: (1, {'@': 1452})}, 1623: {6: (1, {'@': 927}), 60: (1, {'@': 927}), 7: (1, {'@': 927}), 61: (1, {'@': 927}), 126: (1, {'@': 927}), 37: (1, {'@': 927}), 27: (1, {'@': 927}), 28: (1, {'@': 927}), 57: (1, {'@': 927})}, 1624: {60: (0, 1897)}, 1625: {43: (1, {'@': 1031}), 44: (1, {'@': 1031}), 45: (1, {'@': 1031}), 6: (1, {'@': 1031}), 53: (1, {'@': 1031}), 54: (1, {'@': 1031}), 57: (1, {'@': 1031}), 18: (1, {'@': 1031}), 60: (1, {'@': 1031}), 21: (1, {'@': 1031}), 126: (1, {'@': 1031}), 61: (1, {'@': 1031}), 27: (1, {'@': 1031}), 28: (1, {'@': 1031}), 33: (1, {'@': 1031}), 64: (1, {'@': 1031}), 34: (1, {'@': 1031}), 37: (1, {'@': 1031}), 38: (1, {'@': 1031}), 69: (1, {'@': 1031}), 40: (1, {'@': 1031}), 74: (1, {'@': 1031}), 41: (1, {'@': 1031}), 75: (1, {'@': 1031})}, 1626: {6: (1, {'@': 930}), 60: (1, {'@': 930}), 7: (1, {'@': 930}), 61: (1, {'@': 930}), 126: (1, {'@': 930}), 37: (1, {'@': 930}), 27: (1, {'@': 930}), 28: (1, {'@': 930}), 57: (1, {'@': 930})}, 1627: {43: (1, {'@': 1043}), 44: (1, {'@': 1043}), 45: (1, {'@': 1043}), 6: (1, {'@': 1043}), 53: (1, {'@': 1043}), 54: (1, {'@': 1043}), 57: (1, {'@': 1043}), 18: (1, {'@': 1043}), 60: (1, {'@': 1043}), 21: (1, {'@': 1043}), 126: (1, {'@': 1043}), 61: (1, {'@': 1043}), 27: (1, {'@': 1043}), 28: (1, {'@': 1043}), 33: (1, {'@': 1043}), 64: (1, {'@': 1043}), 34: (1, {'@': 1043}), 37: (1, {'@': 1043}), 38: (1, {'@': 1043}), 69: (1, {'@': 1043}), 40: (1, {'@': 1043}), 74: (1, {'@': 1043}), 41: (1, {'@': 1043}), 75: (1, {'@': 1043})}, 1628: {654: (0, 235), 7: (0, 45), 27: (0, 408), 180: (0, 1621), 28: (0, 33), 126: (0, 238), 169: (0, 1623), 61: (0, 25), 165: (0, 1626), 37: (0, 1828), 426: (0, 242), 6: (0, 20), 185: (0, 1636), 183: (0, 1638), 164: (0, 1643), 60: (1, {'@': 924}), 57: (1, {'@': 924})}, 1629: {126: (1, {'@': 1451})}, 1630: {60: (1, {'@': 1070}), 57: (1, {'@': 1070})}, 1631: {43: (1, {'@': 1047}), 44: (1, {'@': 1047}), 45: (1, {'@': 1047}), 6: (1, {'@': 1047}), 53: (1, {'@': 1047}), 54: (1, {'@': 1047}), 57: (1, {'@': 1047}), 18: (1, {'@': 1047}), 60: (1, {'@': 1047}), 21: (1, {'@': 1047}), 126: (1, {'@': 1047}), 61: (1, {'@': 1047}), 27: (1, {'@': 1047}), 28: (1, {'@': 1047}), 33: (1, {'@': 1047}), 64: (1, {'@': 1047}), 34: (1, {'@': 1047}), 37: (1, {'@': 1047}), 38: (1, {'@': 1047}), 69: (1, {'@': 1047}), 40: (1, {'@': 1047}), 74: (1, {'@': 1047}), 41: (1, {'@': 1047}), 75: (1, {'@': 1047})}, 1632: {60: (1, {'@': 623})}, 1633: {}, 1634: {193: (0, 53), 453: (0, 1809), 192: (0, 1814), 452: (0, 1821), 639: (0, 1822)}, 1635: {43: (1, {'@': 1044}), 44: (1, {'@': 1044}), 45: (1, {'@': 1044}), 6: (1, {'@': 1044}), 53: (1, {'@': 1044}), 54: (1, {'@': 1044}), 57: (1, {'@': 1044}), 18: (1, {'@': 1044}), 60: (1, {'@': 1044}), 21: (1, {'@': 1044}), 126: (1, {'@': 1044}), 61: (1, {'@': 1044}), 27: (1, {'@': 1044}), 28: (1, {'@': 1044}), 33: (1, {'@': 1044}), 64: (1, {'@': 1044}), 34: (1, {'@': 1044}), 37: (1, {'@': 1044}), 38: (1, {'@': 1044}), 69: (1, {'@': 1044}), 40: (1, {'@': 1044}), 74: (1, {'@': 1044}), 41: (1, {'@': 1044}), 75: (1, {'@': 1044})}, 1636: {6: (1, {'@': 925}), 60: (1, {'@': 925}), 7: (1, {'@': 925}), 61: (1, {'@': 925}), 126: (1, {'@': 925}), 37: (1, {'@': 925}), 27: (1, {'@': 925}), 28: (1, {'@': 925}), 57: (1, {'@': 925})}, 1637: {126: (1, {'@': 1604}), 60: (1, {'@': 1604})}, 1638: {6: (1, {'@': 926}), 60: (1, {'@': 926}), 7: (1, {'@': 926}), 61: (1, {'@': 926}), 126: (1, {'@': 926}), 37: (1, {'@': 926}), 27: (1, {'@': 926}), 28: (1, {'@': 926}), 57: (1, {'@': 926})}, 1639: {500: (1, {'@': 546}), 60: (1, {'@': 546}), 501: (1, {'@': 546}), 126: (1, {'@': 546}), 57: (1, {'@': 546})}, 1640: {43: (1, {'@': 1033}), 44: (1, {'@': 1033}), 45: (1, {'@': 1033}), 6: (1, {'@': 1033}), 53: (1, {'@': 1033}), 54: (1, {'@': 1033}), 57: (1, {'@': 1033}), 18: (1, {'@': 1033}), 60: (1, {'@': 1033}), 21: (1, {'@': 1033}), 126: (1, {'@': 1033}), 61: (1, {'@': 1033}), 27: (1, {'@': 1033}), 28: (1, {'@': 1033}), 33: (1, {'@': 1033}), 64: (1, {'@': 1033}), 34: (1, {'@': 1033}), 37: (1, {'@': 1033}), 38: (1, {'@': 1033}), 69: (1, {'@': 1033}), 40: (1, {'@': 1033}), 74: (1, {'@': 1033}), 41: (1, {'@': 1033}), 75: (1, {'@': 1033})}, 1641: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 86: (0, 283), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 556: (0, 1174), 35: (0, 844), 559: (0, 1197), 0: (0, 846), 558: (0, 1200), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 557: (0, 1203), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1642: {126: (0, 1910), 441: (0, 1869)}, 1643: {6: (1, {'@': 929}), 60: (1, {'@': 929}), 7: (1, {'@': 929}), 61: (1, {'@': 929}), 126: (1, {'@': 929}), 37: (1, {'@': 929}), 27: (1, {'@': 929}), 28: (1, {'@': 929}), 57: (1, {'@': 929})}, 1644: {505: (0, 503), 503: (0, 1900), 504: (0, 1902), 506: (0, 505)}, 1645: {60: (1, {'@': 324}), 57: (1, {'@': 324})}, 1646: {43: (1, {'@': 1049}), 44: (1, {'@': 1049}), 45: (1, {'@': 1049}), 6: (1, {'@': 1049}), 53: (1, {'@': 1049}), 54: (1, {'@': 1049}), 57: (1, {'@': 1049}), 18: (1, {'@': 1049}), 60: (1, {'@': 1049}), 21: (1, {'@': 1049}), 126: (1, {'@': 1049}), 61: (1, {'@': 1049}), 27: (1, {'@': 1049}), 28: (1, {'@': 1049}), 33: (1, {'@': 1049}), 64: (1, {'@': 1049}), 34: (1, {'@': 1049}), 37: (1, {'@': 1049}), 38: (1, {'@': 1049}), 69: (1, {'@': 1049}), 40: (1, {'@': 1049}), 74: (1, {'@': 1049}), 41: (1, {'@': 1049}), 75: (1, {'@': 1049})}, 1647: {60: (1, {'@': 339}), 57: (1, {'@': 339})}, 1648: {57: (1, {'@': 1118}), 60: (1, {'@': 1118}), 59: (1, {'@': 1118}), 7: (1, {'@': 1118}), 22: (1, {'@': 1118}), 34: (1, {'@': 1118}), 53: (1, {'@': 1118}), 126: (1, {'@': 1118}), 69: (1, {'@': 1118}), 49: (1, {'@': 1118})}, 1649: {60: (1, {'@': 303}), 57: (1, {'@': 303})}, 1650: {43: (1, {'@': 1041}), 44: (1, {'@': 1041}), 45: (1, {'@': 1041}), 6: (1, {'@': 1041}), 53: (1, {'@': 1041}), 54: (1, {'@': 1041}), 57: (1, {'@': 1041}), 18: (1, {'@': 1041}), 60: (1, {'@': 1041}), 21: (1, {'@': 1041}), 126: (1, {'@': 1041}), 61: (1, {'@': 1041}), 27: (1, {'@': 1041}), 28: (1, {'@': 1041}), 33: (1, {'@': 1041}), 64: (1, {'@': 1041}), 34: (1, {'@': 1041}), 37: (1, {'@': 1041}), 38: (1, {'@': 1041}), 69: (1, {'@': 1041}), 40: (1, {'@': 1041}), 74: (1, {'@': 1041}), 41: (1, {'@': 1041}), 75: (1, {'@': 1041})}, 1651: {60: (1, {'@': 343}), 57: (1, {'@': 343})}, 1652: {57: (1, {'@': 1121}), 60: (1, {'@': 1121}), 59: (1, {'@': 1121}), 7: (1, {'@': 1121}), 22: (1, {'@': 1121}), 34: (1, {'@': 1121}), 53: (1, {'@': 1121}), 126: (1, {'@': 1121}), 69: (1, {'@': 1121}), 49: (1, {'@': 1121})}, 1653: {22: (0, 389), 53: (0, 387), 655: (0, 1771), 205: (0, 1825), 447: (0, 1829), 62: (0, 367), 206: (0, 1838), 172: (0, 1841)}, 1654: {43: (1, {'@': 1046}), 44: (1, {'@': 1046}), 45: (1, {'@': 1046}), 6: (1, {'@': 1046}), 53: (1, {'@': 1046}), 54: (1, {'@': 1046}), 57: (1, {'@': 1046}), 18: (1, {'@': 1046}), 60: (1, {'@': 1046}), 21: (1, {'@': 1046}), 126: (1, {'@': 1046}), 61: (1, {'@': 1046}), 27: (1, {'@': 1046}), 28: (1, {'@': 1046}), 33: (1, {'@': 1046}), 64: (1, {'@': 1046}), 34: (1, {'@': 1046}), 37: (1, {'@': 1046}), 38: (1, {'@': 1046}), 69: (1, {'@': 1046}), 40: (1, {'@': 1046}), 74: (1, {'@': 1046}), 41: (1, {'@': 1046}), 75: (1, {'@': 1046})}, 1655: {57: (1, {'@': 560}), 60: (1, {'@': 560})}, 1656: {60: (1, {'@': 1111}), 57: (1, {'@': 1111})}, 1657: {43: (1, {'@': 1039}), 44: (1, {'@': 1039}), 45: (1, {'@': 1039}), 6: (1, {'@': 1039}), 53: (1, {'@': 1039}), 54: (1, {'@': 1039}), 57: (1, {'@': 1039}), 18: (1, {'@': 1039}), 60: (1, {'@': 1039}), 21: (1, {'@': 1039}), 126: (1, {'@': 1039}), 61: (1, {'@': 1039}), 27: (1, {'@': 1039}), 28: (1, {'@': 1039}), 33: (1, {'@': 1039}), 64: (1, {'@': 1039}), 34: (1, {'@': 1039}), 37: (1, {'@': 1039}), 38: (1, {'@': 1039}), 69: (1, {'@': 1039}), 40: (1, {'@': 1039}), 74: (1, {'@': 1039}), 41: (1, {'@': 1039}), 75: (1, {'@': 1039})}, 1658: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 86: (0, 1190), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 194: (0, 1194), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1659: {441: (0, 1908), 126: (0, 1910)}, 1660: {22: (0, 389), 53: (0, 387), 172: (0, 1648), 7: (0, 45), 200: (0, 1652), 59: (0, 363), 406: (0, 226), 49: (0, 335), 198: (0, 1667), 34: (0, 1589), 69: (0, 1760), 212: (0, 1669), 206: (0, 1673), 287: (0, 1676), 126: (0, 197), 180: (0, 1678), 60: (1, {'@': 1115}), 57: (1, {'@': 1115})}, 1661: {126: (1, {'@': 1606}), 60: (1, {'@': 1606})}, 1662: {60: (1, {'@': 340}), 57: (1, {'@': 340})}, 1663: {60: (1, {'@': 358}), 57: (1, {'@': 358})}, 1664: {22: (0, 389), 53: (0, 387), 18: (0, 1581), 172: (0, 1872), 33: (0, 383), 64: (0, 1537), 200: (0, 1876), 44: (0, 358), 183: (0, 1880), 62: (0, 367), 21: (0, 366), 164: (0, 1883), 287: (0, 1886), 204: (0, 1889), 75: (0, 341), 34: (0, 1589), 28: (0, 33), 61: (0, 25), 476: (0, 1894), 208: (0, 1904), 205: (0, 1907), 207: (0, 1912), 280: (0, 1916), 213: (0, 1919), 54: (0, 1598), 283: (0, 1922), 40: (0, 1756), 69: (0, 1760), 656: (0, 1927), 185: (0, 1932), 211: (0, 1936), 210: (0, 1941), 206: (0, 1946), 73: (0, 1763), 6: (0, 20), 286: (0, 1951), 0: (1, {'@': 430}), 3: (1, {'@': 430}), 20: (1, {'@': 430}), 32: (1, {'@': 430}), 65: (1, {'@': 430}), 10: (1, {'@': 430}), 35: (1, {'@': 430}), 12: (1, {'@': 430}), 46: (1, {'@': 430}), 24: (1, {'@': 430}), 14: (1, {'@': 430}), 13: (1, {'@': 430}), 39: (1, {'@': 430}), 42: (1, {'@': 430}), 56: (1, {'@': 430}), 16: (1, {'@': 430}), 5: (1, {'@': 430}), 19: (1, {'@': 430}), 60: (1, {'@': 1005}), 57: (1, {'@': 1005})}, 1665: {299: (0, 1524), 298: (0, 2310), 126: (0, 1716), 57: (1, {'@': 762}), 60: (1, {'@': 762})}, 1666: {112: (0, 2331)}, 1667: {57: (1, {'@': 1117}), 60: (1, {'@': 1117}), 59: (1, {'@': 1117}), 7: (1, {'@': 1117}), 22: (1, {'@': 1117}), 34: (1, {'@': 1117}), 53: (1, {'@': 1117}), 126: (1, {'@': 1117}), 69: (1, {'@': 1117}), 49: (1, {'@': 1117})}, 1668: {126: (1, {'@': 1601}), 146: (1, {'@': 1601})}, 1669: {57: (1, {'@': 1119}), 60: (1, {'@': 1119}), 59: (1, {'@': 1119}), 7: (1, {'@': 1119}), 22: (1, {'@': 1119}), 34: (1, {'@': 1119}), 53: (1, {'@': 1119}), 126: (1, {'@': 1119}), 69: (1, {'@': 1119}), 49: (1, {'@': 1119})}, 1670: {126: (1, {'@': 1739}), 60: (1, {'@': 1739})}, 1671: {33: (1, {'@': 854}), 58: (1, {'@': 854}), 6: (1, {'@': 854}), 60: (1, {'@': 854}), 44: (1, {'@': 854}), 66: (1, {'@': 854}), 53: (1, {'@': 854}), 126: (1, {'@': 854}), 37: (1, {'@': 854}), 28: (1, {'@': 854}), 57: (1, {'@': 854})}, 1672: {470: (0, 1862), 471: (0, 1848), 387: (0, 1852), 624: (0, 1845), 388: (0, 1864), 625: (0, 1851), 626: (0, 1868), 60: (1, {'@': 1340}), 57: (1, {'@': 1340})}, 1673: {57: (1, {'@': 1116}), 60: (1, {'@': 1116}), 59: (1, {'@': 1116}), 7: (1, {'@': 1116}), 22: (1, {'@': 1116}), 34: (1, {'@': 1116}), 53: (1, {'@': 1116}), 126: (1, {'@': 1116}), 69: (1, {'@': 1116}), 49: (1, {'@': 1116})}, 1674: {107: (0, 558), 427: (0, 1905), 144: (0, 580)}, 1675: {58: (0, 1666), 172: (0, 1671), 53: (0, 387), 33: (0, 383), 44: (0, 358), 66: (0, 1679), 294: (0, 122), 210: (0, 1680), 183: (0, 1685), 295: (0, 1688), 28: (0, 33), 165: (0, 1693), 204: (0, 1696), 296: (0, 1701), 37: (0, 1828), 126: (0, 123), 6: (0, 20), 185: (0, 1710), 57: (1, {'@': 850}), 60: (1, {'@': 850})}, 1676: {57: (1, {'@': 1122}), 60: (1, {'@': 1122}), 59: (1, {'@': 1122}), 7: (1, {'@': 1122}), 22: (1, {'@': 1122}), 34: (1, {'@': 1122}), 53: (1, {'@': 1122}), 126: (1, {'@': 1122}), 69: (1, {'@': 1122}), 49: (1, {'@': 1122})}, 1677: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 86: (0, 695), 35: (0, 844), 194: (0, 707), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 1678: {57: (1, {'@': 1120}), 60: (1, {'@': 1120}), 59: (1, {'@': 1120}), 7: (1, {'@': 1120}), 22: (1, {'@': 1120}), 34: (1, {'@': 1120}), 53: (1, {'@': 1120}), 126: (1, {'@': 1120}), 69: (1, {'@': 1120}), 49: (1, {'@': 1120})}, 1679: {112: (0, 2587)}, 1680: {33: (1, {'@': 857}), 58: (1, {'@': 857}), 6: (1, {'@': 857}), 60: (1, {'@': 857}), 44: (1, {'@': 857}), 66: (1, {'@': 857}), 53: (1, {'@': 857}), 126: (1, {'@': 857}), 37: (1, {'@': 857}), 28: (1, {'@': 857}), 57: (1, {'@': 857})}, 1681: {57: (1, {'@': 998}), 60: (1, {'@': 998}), 126: (1, {'@': 998}), 61: (1, {'@': 998}), 37: (1, {'@': 998}), 38: (1, {'@': 998}), 26: (1, {'@': 998}), 27: (1, {'@': 998}), 51: (1, {'@': 998})}, 1682: {60: (1, {'@': 308}), 57: (1, {'@': 308})}, 1683: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 1937)}, 1684: {204: (0, 1972), 165: (0, 2211), 479: (0, 2215), 53: (0, 387), 33: (0, 383), 63: (0, 2218), 164: (0, 2221), 44: (0, 358), 2: (0, 2225), 55: (0, 2229), 480: (0, 2232), 185: (0, 2239), 481: (0, 2240), 8: (0, 1510), 52: (0, 1498), 28: (0, 33), 210: (0, 2244), 61: (0, 25), 482: (0, 2248), 483: (0, 2251), 290: (0, 2257), 657: (0, 2260), 37: (0, 1828), 71: (0, 2263), 6: (0, 20), 183: (0, 2267), 292: (0, 2274), 172: (0, 2278), 0: (1, {'@': 419}), 3: (1, {'@': 419}), 20: (1, {'@': 419}), 32: (1, {'@': 419}), 65: (1, {'@': 419}), 10: (1, {'@': 419}), 35: (1, {'@': 419}), 12: (1, {'@': 419}), 46: (1, {'@': 419}), 24: (1, {'@': 419}), 14: (1, {'@': 419}), 13: (1, {'@': 419}), 39: (1, {'@': 419}), 42: (1, {'@': 419}), 56: (1, {'@': 419}), 16: (1, {'@': 419}), 5: (1, {'@': 419}), 19: (1, {'@': 419}), 60: (1, {'@': 813}), 57: (1, {'@': 813})}, 1685: {33: (1, {'@': 853}), 58: (1, {'@': 853}), 6: (1, {'@': 853}), 60: (1, {'@': 853}), 44: (1, {'@': 853}), 66: (1, {'@': 853}), 53: (1, {'@': 853}), 126: (1, {'@': 853}), 37: (1, {'@': 853}), 28: (1, {'@': 853}), 57: (1, {'@': 853})}, 1686: {167: (0, 1614), 165: (0, 1681), 126: (0, 200), 164: (0, 1694), 27: (0, 408), 51: (0, 1695), 26: (0, 1797), 163: (0, 1698), 38: (0, 1811), 61: (0, 25), 410: (0, 1703), 169: (0, 1708), 37: (0, 1828), 411: (0, 248), 60: (1, {'@': 992}), 57: (1, {'@': 992})}, 1687: {60: (0, 1855)}, 1688: {33: (1, {'@': 855}), 58: (1, {'@': 855}), 6: (1, {'@': 855}), 60: (1, {'@': 855}), 44: (1, {'@': 855}), 66: (1, {'@': 855}), 53: (1, {'@': 855}), 126: (1, {'@': 855}), 37: (1, {'@': 855}), 28: (1, {'@': 855}), 57: (1, {'@': 855})}, 1689: {144: (0, 2316), 145: (0, 1816)}, 1690: {12: (0, 2406), 219: (0, 1099), 16: (0, 2407), 109: (0, 2410), 14: (0, 2413)}, 1691: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 194: (0, 1938), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 1692: {400: (0, 1799), 401: (0, 1962), 192: (0, 1970), 193: (0, 53), 658: (0, 1473)}, 1693: {33: (1, {'@': 856}), 58: (1, {'@': 856}), 6: (1, {'@': 856}), 60: (1, {'@': 856}), 44: (1, {'@': 856}), 66: (1, {'@': 856}), 53: (1, {'@': 856}), 126: (1, {'@': 856}), 37: (1, {'@': 856}), 28: (1, {'@': 856}), 57: (1, {'@': 856})}, 1694: {57: (1, {'@': 997}), 60: (1, {'@': 997}), 126: (1, {'@': 997}), 61: (1, {'@': 997}), 37: (1, {'@': 997}), 38: (1, {'@': 997}), 26: (1, {'@': 997}), 27: (1, {'@': 997}), 51: (1, {'@': 997})}, 1695: {112: (0, 234)}, 1696: {33: (1, {'@': 852}), 58: (1, {'@': 852}), 6: (1, {'@': 852}), 60: (1, {'@': 852}), 44: (1, {'@': 852}), 66: (1, {'@': 852}), 53: (1, {'@': 852}), 126: (1, {'@': 852}), 37: (1, {'@': 852}), 28: (1, {'@': 852}), 57: (1, {'@': 852})}, 1697: {60: (1, {'@': 1173})}, 1698: {57: (1, {'@': 996}), 60: (1, {'@': 996}), 126: (1, {'@': 996}), 61: (1, {'@': 996}), 37: (1, {'@': 996}), 38: (1, {'@': 996}), 26: (1, {'@': 996}), 27: (1, {'@': 996}), 51: (1, {'@': 996})}, 1699: {60: (1, {'@': 1172})}, 1700: {60: (1, {'@': 321}), 57: (1, {'@': 321})}, 1701: {33: (1, {'@': 858}), 58: (1, {'@': 858}), 6: (1, {'@': 858}), 60: (1, {'@': 858}), 44: (1, {'@': 858}), 66: (1, {'@': 858}), 53: (1, {'@': 858}), 126: (1, {'@': 858}), 37: (1, {'@': 858}), 28: (1, {'@': 858}), 57: (1, {'@': 858})}, 1702: {60: (1, {'@': 328}), 57: (1, {'@': 328})}, 1703: {57: (1, {'@': 993}), 60: (1, {'@': 993}), 126: (1, {'@': 993}), 61: (1, {'@': 993}), 37: (1, {'@': 993}), 38: (1, {'@': 993}), 26: (1, {'@': 993}), 27: (1, {'@': 993}), 51: (1, {'@': 993})}, 1704: {500: (1, {'@': 1621}), 60: (1, {'@': 1621}), 501: (1, {'@': 1621}), 126: (1, {'@': 1621}), 57: (1, {'@': 1621})}, 1705: {60: (1, {'@': 320}), 57: (1, {'@': 320})}, 1706: {60: (1, {'@': 846}), 57: (1, {'@': 846})}, 1707: {60: (1, {'@': 317}), 57: (1, {'@': 317})}, 1708: {57: (1, {'@': 995}), 60: (1, {'@': 995}), 126: (1, {'@': 995}), 61: (1, {'@': 995}), 37: (1, {'@': 995}), 38: (1, {'@': 995}), 26: (1, {'@': 995}), 27: (1, {'@': 995}), 51: (1, {'@': 995})}, 1709: {60: (1, {'@': 354}), 57: (1, {'@': 354})}, 1710: {33: (1, {'@': 851}), 58: (1, {'@': 851}), 6: (1, {'@': 851}), 60: (1, {'@': 851}), 44: (1, {'@': 851}), 66: (1, {'@': 851}), 53: (1, {'@': 851}), 126: (1, {'@': 851}), 37: (1, {'@': 851}), 28: (1, {'@': 851}), 57: (1, {'@': 851})}, 1711: {522: (0, 623), 523: (0, 1925)}, 1712: {11: (0, 84), 484: (0, 966), 0: (1, {'@': 422}), 3: (1, {'@': 422}), 20: (1, {'@': 422}), 32: (1, {'@': 422}), 65: (1, {'@': 422}), 10: (1, {'@': 422}), 35: (1, {'@': 422}), 12: (1, {'@': 422}), 46: (1, {'@': 422}), 24: (1, {'@': 422}), 14: (1, {'@': 422}), 13: (1, {'@': 422}), 39: (1, {'@': 422}), 42: (1, {'@': 422}), 56: (1, {'@': 422}), 16: (1, {'@': 422}), 5: (1, {'@': 422}), 19: (1, {'@': 422}), 60: (1, {'@': 897}), 57: (1, {'@': 897})}, 1713: {60: (1, {'@': 988}), 57: (1, {'@': 988})}, 1714: {57: (1, {'@': 512}), 60: (1, {'@': 512})}, 1715: {57: (1, {'@': 520}), 60: (1, {'@': 520})}, 1716: {299: (0, 1524), 298: (0, 2115)}, 1717: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 86: (0, 1943), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 80: (0, 2149), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 76: (0, 1947), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 1718: {144: (0, 250)}, 1719: {126: (1, {'@': 1734}), 60: (1, {'@': 1734}), 146: (1, {'@': 1734})}, 1720: {60: (1, {'@': 322}), 57: (1, {'@': 322})}, 1721: {60: (1, {'@': 760}), 57: (1, {'@': 760})}, 1722: {60: (1, {'@': 327}), 57: (1, {'@': 327})}, 1723: {7: (0, 45), 185: (0, 1730), 183: (0, 1733), 28: (0, 33), 164: (0, 1736), 61: (0, 25), 301: (0, 134), 37: (0, 1828), 180: (0, 1741), 6: (0, 20), 165: (0, 1750), 126: (0, 135), 57: (1, {'@': 915}), 60: (1, {'@': 915})}, 1724: {112: (0, 160)}, 1725: {60: (1, {'@': 319}), 57: (1, {'@': 319})}, 1726: {60: (1, {'@': 330}), 57: (1, {'@': 330})}, 1727: {112: (0, 139)}, 1728: {86: (0, 2359), 115: (0, 44), 77: (0, 17), 108: (0, 400), 311: (0, 2361), 312: (0, 2365), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 659: (0, 2368), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 124: (0, 864), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 314: (0, 2369), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 310: (0, 2372), 102: (0, 823), 103: (0, 825), 14: (0, 399), 20: (0, 822), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 313: (0, 2377), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863)}, 1729: {185: (0, 311), 469: (0, 2282), 640: (0, 2284), 477: (0, 2288), 6: (0, 20), 478: (0, 2296), 60: (1, {'@': 1239}), 57: (1, {'@': 1239})}, 1730: {6: (1, {'@': 916}), 60: (1, {'@': 916}), 7: (1, {'@': 916}), 61: (1, {'@': 916}), 126: (1, {'@': 916}), 37: (1, {'@': 916}), 28: (1, {'@': 916}), 57: (1, {'@': 916})}, 1731: {22: (0, 389), 53: (0, 387), 126: (0, 266), 7: (0, 45), 68: (0, 1724), 70: (0, 1727), 444: (0, 1742), 49: (0, 335), 34: (0, 1589), 206: (0, 1747), 198: (0, 1751), 445: (0, 1754), 69: (0, 1760), 172: (0, 1757), 180: (0, 1761), 446: (0, 269), 287: (0, 1764), 200: (0, 1766), 57: (1, {'@': 1185}), 60: (1, {'@': 1185})}, 1732: {539: (0, 739), 538: (0, 1923), 60: (1, {'@': 498}), 57: (1, {'@': 498})}, 1733: {6: (1, {'@': 917}), 60: (1, {'@': 917}), 7: (1, {'@': 917}), 61: (1, {'@': 917}), 126: (1, {'@': 917}), 37: (1, {'@': 917}), 28: (1, {'@': 917}), 57: (1, {'@': 917})}, 1734: {144: (0, 2316), 145: (0, 259)}, 1735: {60: (1, {'@': 304}), 57: (1, {'@': 304})}, 1736: {6: (1, {'@': 919}), 60: (1, {'@': 919}), 7: (1, {'@': 919}), 61: (1, {'@': 919}), 126: (1, {'@': 919}), 37: (1, {'@': 919}), 28: (1, {'@': 919}), 57: (1, {'@': 919})}, 1737: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 86: (0, 1967), 79: (0, 1973), 116: (0, 780), 80: (0, 2149), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 76: (0, 1971), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1738: {60: (1, {'@': 341}), 57: (1, {'@': 341})}, 1739: {60: (1, {'@': 1181}), 57: (1, {'@': 1181})}, 1740: {60: (1, {'@': 323}), 57: (1, {'@': 323})}, 1741: {6: (1, {'@': 918}), 60: (1, {'@': 918}), 7: (1, {'@': 918}), 61: (1, {'@': 918}), 126: (1, {'@': 918}), 37: (1, {'@': 918}), 28: (1, {'@': 918}), 57: (1, {'@': 918})}, 1742: {57: (1, {'@': 1188}), 60: (1, {'@': 1188}), 7: (1, {'@': 1188}), 22: (1, {'@': 1188}), 126: (1, {'@': 1188}), 53: (1, {'@': 1188}), 34: (1, {'@': 1188}), 68: (1, {'@': 1188}), 69: (1, {'@': 1188}), 70: (1, {'@': 1188}), 49: (1, {'@': 1188})}, 1743: {57: (1, {'@': 501}), 60: (1, {'@': 501})}, 1744: {60: (1, {'@': 325}), 57: (1, {'@': 325})}, 1745: {60: (1, {'@': 310}), 57: (1, {'@': 310})}, 1746: {60: (1, {'@': 911}), 57: (1, {'@': 911})}, 1747: {57: (1, {'@': 1186}), 60: (1, {'@': 1186}), 7: (1, {'@': 1186}), 22: (1, {'@': 1186}), 126: (1, {'@': 1186}), 53: (1, {'@': 1186}), 34: (1, {'@': 1186}), 68: (1, {'@': 1186}), 69: (1, {'@': 1186}), 70: (1, {'@': 1186}), 49: (1, {'@': 1186})}, 1748: {60: (1, {'@': 338}), 57: (1, {'@': 338})}, 1749: {60: (1, {'@': 309}), 57: (1, {'@': 309})}, 1750: {6: (1, {'@': 920}), 60: (1, {'@': 920}), 7: (1, {'@': 920}), 61: (1, {'@': 920}), 126: (1, {'@': 920}), 37: (1, {'@': 920}), 28: (1, {'@': 920}), 57: (1, {'@': 920})}, 1751: {57: (1, {'@': 1187}), 60: (1, {'@': 1187}), 7: (1, {'@': 1187}), 22: (1, {'@': 1187}), 126: (1, {'@': 1187}), 53: (1, {'@': 1187}), 34: (1, {'@': 1187}), 68: (1, {'@': 1187}), 69: (1, {'@': 1187}), 70: (1, {'@': 1187}), 49: (1, {'@': 1187})}, 1752: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 80: (0, 2149), 79: (0, 1973), 86: (0, 1975), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 76: (0, 2214), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 1753: {60: (1, {'@': 1084}), 57: (1, {'@': 1084})}, 1754: {57: (1, {'@': 1193}), 60: (1, {'@': 1193}), 7: (1, {'@': 1193}), 22: (1, {'@': 1193}), 126: (1, {'@': 1193}), 53: (1, {'@': 1193}), 34: (1, {'@': 1193}), 68: (1, {'@': 1193}), 69: (1, {'@': 1193}), 70: (1, {'@': 1193}), 49: (1, {'@': 1193})}, 1755: {57: (1, {'@': 510}), 60: (1, {'@': 510})}, 1756: {112: (0, 2514), 59: (1, {'@': 1484}), 60: (1, {'@': 1484}), 21: (1, {'@': 1484}), 22: (1, {'@': 1484}), 44: (1, {'@': 1484}), 126: (1, {'@': 1484}), 62: (1, {'@': 1484}), 61: (1, {'@': 1484}), 23: (1, {'@': 1484}), 25: (1, {'@': 1484}), 28: (1, {'@': 1484}), 49: (1, {'@': 1484}), 6: (1, {'@': 1484}), 33: (1, {'@': 1484}), 7: (1, {'@': 1484}), 53: (1, {'@': 1484}), 69: (1, {'@': 1484}), 40: (1, {'@': 1484}), 41: (1, {'@': 1484}), 75: (1, {'@': 1484}), 73: (1, {'@': 1484}), 57: (1, {'@': 1484}), 43: (1, {'@': 1484}), 45: (1, {'@': 1484}), 27: (1, {'@': 1484}), 64: (1, {'@': 1484}), 34: (1, {'@': 1484}), 37: (1, {'@': 1484}), 54: (1, {'@': 1484}), 38: (1, {'@': 1484}), 74: (1, {'@': 1484}), 18: (1, {'@': 1484}), 1: (1, {'@': 1484}), 2: (1, {'@': 1484}), 47: (1, {'@': 1484}), 48: (1, {'@': 1484}), 4: (1, {'@': 1484}), 50: (1, {'@': 1484}), 51: (1, {'@': 1484}), 52: (1, {'@': 1484}), 8: (1, {'@': 1484}), 9: (1, {'@': 1484}), 11: (1, {'@': 1484}), 55: (1, {'@': 1484}), 15: (1, {'@': 1484}), 17: (1, {'@': 1484}), 58: (1, {'@': 1484}), 26: (1, {'@': 1484}), 63: (1, {'@': 1484}), 29: (1, {'@': 1484}), 30: (1, {'@': 1484}), 31: (1, {'@': 1484}), 66: (1, {'@': 1484}), 67: (1, {'@': 1484}), 36: (1, {'@': 1484}), 68: (1, {'@': 1484}), 70: (1, {'@': 1484}), 71: (1, {'@': 1484}), 72: (1, {'@': 1484})}, 1757: {57: (1, {'@': 1189}), 60: (1, {'@': 1189}), 7: (1, {'@': 1189}), 22: (1, {'@': 1189}), 126: (1, {'@': 1189}), 53: (1, {'@': 1189}), 34: (1, {'@': 1189}), 68: (1, {'@': 1189}), 69: (1, {'@': 1189}), 70: (1, {'@': 1189}), 49: (1, {'@': 1189})}, 1758: {144: (0, 2316), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 86: (0, 246), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 145: (0, 2157), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1759: {59: (1, {'@': 1618}), 60: (1, {'@': 1618}), 57: (1, {'@': 1618})}, 1760: {112: (0, 2536)}, 1761: {57: (1, {'@': 1190}), 60: (1, {'@': 1190}), 7: (1, {'@': 1190}), 22: (1, {'@': 1190}), 126: (1, {'@': 1190}), 53: (1, {'@': 1190}), 34: (1, {'@': 1190}), 68: (1, {'@': 1190}), 69: (1, {'@': 1190}), 70: (1, {'@': 1190}), 49: (1, {'@': 1190})}, 1762: {144: (0, 125)}, 1763: {112: (0, 2538)}, 1764: {57: (1, {'@': 1192}), 60: (1, {'@': 1192}), 7: (1, {'@': 1192}), 22: (1, {'@': 1192}), 126: (1, {'@': 1192}), 53: (1, {'@': 1192}), 34: (1, {'@': 1192}), 68: (1, {'@': 1192}), 69: (1, {'@': 1192}), 70: (1, {'@': 1192}), 49: (1, {'@': 1192})}, 1765: {44: (1, {'@': 1095}), 49: (1, {'@': 1095}), 6: (1, {'@': 1095}), 7: (1, {'@': 1095}), 53: (1, {'@': 1095}), 57: (1, {'@': 1095}), 59: (1, {'@': 1095}), 60: (1, {'@': 1095}), 21: (1, {'@': 1095}), 22: (1, {'@': 1095}), 126: (1, {'@': 1095}), 62: (1, {'@': 1095}), 61: (1, {'@': 1095}), 23: (1, {'@': 1095}), 25: (1, {'@': 1095}), 28: (1, {'@': 1095}), 33: (1, {'@': 1095}), 69: (1, {'@': 1095}), 40: (1, {'@': 1095}), 41: (1, {'@': 1095}), 75: (1, {'@': 1095}), 73: (1, {'@': 1095})}, 1766: {57: (1, {'@': 1191}), 60: (1, {'@': 1191}), 7: (1, {'@': 1191}), 22: (1, {'@': 1191}), 126: (1, {'@': 1191}), 53: (1, {'@': 1191}), 34: (1, {'@': 1191}), 68: (1, {'@': 1191}), 69: (1, {'@': 1191}), 70: (1, {'@': 1191}), 49: (1, {'@': 1191})}, 1767: {57: (1, {'@': 503}), 60: (1, {'@': 503})}, 1768: {538: (0, 1956), 539: (0, 739)}, 1769: {44: (1, {'@': 1103}), 49: (1, {'@': 1103}), 6: (1, {'@': 1103}), 7: (1, {'@': 1103}), 53: (1, {'@': 1103}), 57: (1, {'@': 1103}), 59: (1, {'@': 1103}), 60: (1, {'@': 1103}), 21: (1, {'@': 1103}), 22: (1, {'@': 1103}), 126: (1, {'@': 1103}), 62: (1, {'@': 1103}), 61: (1, {'@': 1103}), 23: (1, {'@': 1103}), 25: (1, {'@': 1103}), 28: (1, {'@': 1103}), 33: (1, {'@': 1103}), 69: (1, {'@': 1103}), 40: (1, {'@': 1103}), 41: (1, {'@': 1103}), 75: (1, {'@': 1103}), 73: (1, {'@': 1103})}, 1770: {112: (0, 1)}, 1771: {60: (1, {'@': 1063}), 57: (1, {'@': 1063})}, 1772: {112: (0, 257)}, 1773: {177: (1, {'@': 602}), 7: (1, {'@': 602}), 22: (1, {'@': 602}), 60: (1, {'@': 602}), 126: (1, {'@': 602}), 48: (1, {'@': 602}), 72: (1, {'@': 602}), 178: (1, {'@': 602}), 179: (1, {'@': 602}), 49: (1, {'@': 602}), 57: (1, {'@': 602}), 43: (1, {'@': 602}), 1: (1, {'@': 602}), 2: (1, {'@': 602}), 44: (1, {'@': 602}), 45: (1, {'@': 602}), 47: (1, {'@': 602}), 4: (1, {'@': 602}), 50: (1, {'@': 602}), 51: (1, {'@': 602}), 6: (1, {'@': 602}), 52: (1, {'@': 602}), 8: (1, {'@': 602}), 9: (1, {'@': 602}), 53: (1, {'@': 602}), 11: (1, {'@': 602}), 54: (1, {'@': 602}), 55: (1, {'@': 602}), 15: (1, {'@': 602}), 17: (1, {'@': 602}), 18: (1, {'@': 602}), 58: (1, {'@': 602}), 59: (1, {'@': 602}), 21: (1, {'@': 602}), 61: (1, {'@': 602}), 62: (1, {'@': 602}), 23: (1, {'@': 602}), 25: (1, {'@': 602}), 26: (1, {'@': 602}), 63: (1, {'@': 602}), 27: (1, {'@': 602}), 28: (1, {'@': 602}), 29: (1, {'@': 602}), 30: (1, {'@': 602}), 31: (1, {'@': 602}), 33: (1, {'@': 602}), 64: (1, {'@': 602}), 66: (1, {'@': 602}), 67: (1, {'@': 602}), 34: (1, {'@': 602}), 36: (1, {'@': 602}), 37: (1, {'@': 602}), 68: (1, {'@': 602}), 38: (1, {'@': 602}), 69: (1, {'@': 602}), 70: (1, {'@': 602}), 71: (1, {'@': 602}), 40: (1, {'@': 602}), 41: (1, {'@': 602}), 73: (1, {'@': 602}), 74: (1, {'@': 602}), 75: (1, {'@': 602})}, 1774: {44: (1, {'@': 1098}), 49: (1, {'@': 1098}), 6: (1, {'@': 1098}), 7: (1, {'@': 1098}), 53: (1, {'@': 1098}), 57: (1, {'@': 1098}), 59: (1, {'@': 1098}), 60: (1, {'@': 1098}), 21: (1, {'@': 1098}), 22: (1, {'@': 1098}), 126: (1, {'@': 1098}), 62: (1, {'@': 1098}), 61: (1, {'@': 1098}), 23: (1, {'@': 1098}), 25: (1, {'@': 1098}), 28: (1, {'@': 1098}), 33: (1, {'@': 1098}), 69: (1, {'@': 1098}), 40: (1, {'@': 1098}), 41: (1, {'@': 1098}), 75: (1, {'@': 1098}), 73: (1, {'@': 1098})}, 1775: {60: (1, {'@': 757}), 57: (1, {'@': 757})}, 1776: {1: (1, {'@': 983}), 6: (1, {'@': 983}), 60: (1, {'@': 983}), 61: (1, {'@': 983}), 126: (1, {'@': 983}), 45: (1, {'@': 983}), 38: (1, {'@': 983}), 26: (1, {'@': 983}), 27: (1, {'@': 983}), 28: (1, {'@': 983}), 57: (1, {'@': 983})}, 1777: {60: (1, {'@': 756}), 57: (1, {'@': 756})}, 1778: {44: (1, {'@': 1097}), 49: (1, {'@': 1097}), 6: (1, {'@': 1097}), 7: (1, {'@': 1097}), 53: (1, {'@': 1097}), 57: (1, {'@': 1097}), 59: (1, {'@': 1097}), 60: (1, {'@': 1097}), 21: (1, {'@': 1097}), 22: (1, {'@': 1097}), 126: (1, {'@': 1097}), 62: (1, {'@': 1097}), 61: (1, {'@': 1097}), 23: (1, {'@': 1097}), 25: (1, {'@': 1097}), 28: (1, {'@': 1097}), 33: (1, {'@': 1097}), 69: (1, {'@': 1097}), 40: (1, {'@': 1097}), 41: (1, {'@': 1097}), 75: (1, {'@': 1097}), 73: (1, {'@': 1097})}, 1779: {1: (1, {'@': 979}), 6: (1, {'@': 979}), 60: (1, {'@': 979}), 61: (1, {'@': 979}), 126: (1, {'@': 979}), 45: (1, {'@': 979}), 38: (1, {'@': 979}), 26: (1, {'@': 979}), 27: (1, {'@': 979}), 28: (1, {'@': 979}), 57: (1, {'@': 979})}, 1780: {60: (1, {'@': 1370}), 57: (1, {'@': 1370})}, 1781: {515: (1, {'@': 578}), 517: (1, {'@': 578}), 60: (1, {'@': 578}), 126: (1, {'@': 578}), 514: (1, {'@': 578}), 57: (1, {'@': 578})}, 1782: {1: (1, {'@': 977}), 6: (1, {'@': 977}), 60: (1, {'@': 977}), 61: (1, {'@': 977}), 126: (1, {'@': 977}), 45: (1, {'@': 977}), 38: (1, {'@': 977}), 26: (1, {'@': 977}), 27: (1, {'@': 977}), 28: (1, {'@': 977}), 57: (1, {'@': 977})}, 1783: {112: (0, 2542)}, 1784: {60: (1, {'@': 971}), 57: (1, {'@': 971})}, 1785: {193: (0, 53), 126: (0, 264), 192: (0, 274), 57: (1, {'@': 788}), 60: (1, {'@': 788})}, 1786: {1: (1, {'@': 982}), 6: (1, {'@': 982}), 60: (1, {'@': 982}), 61: (1, {'@': 982}), 126: (1, {'@': 982}), 45: (1, {'@': 982}), 38: (1, {'@': 982}), 26: (1, {'@': 982}), 27: (1, {'@': 982}), 28: (1, {'@': 982}), 57: (1, {'@': 982})}, 1787: {660: (0, 1964), 431: (0, 2224), 435: (0, 2226)}, 1788: {44: (1, {'@': 1092}), 49: (1, {'@': 1092}), 6: (1, {'@': 1092}), 7: (1, {'@': 1092}), 53: (1, {'@': 1092}), 57: (1, {'@': 1092}), 59: (1, {'@': 1092}), 60: (1, {'@': 1092}), 21: (1, {'@': 1092}), 22: (1, {'@': 1092}), 126: (1, {'@': 1092}), 62: (1, {'@': 1092}), 61: (1, {'@': 1092}), 23: (1, {'@': 1092}), 25: (1, {'@': 1092}), 28: (1, {'@': 1092}), 33: (1, {'@': 1092}), 69: (1, {'@': 1092}), 40: (1, {'@': 1092}), 41: (1, {'@': 1092}), 75: (1, {'@': 1092}), 73: (1, {'@': 1092})}, 1789: {164: (0, 1776), 27: (0, 408), 183: (0, 1779), 26: (0, 1797), 167: (0, 1782), 38: (0, 1811), 308: (0, 152), 28: (0, 33), 163: (0, 1786), 61: (0, 25), 1: (0, 1793), 185: (0, 1796), 126: (0, 153), 45: (0, 1833), 169: (0, 1798), 168: (0, 1803), 6: (0, 20), 309: (0, 1808), 57: (1, {'@': 975}), 60: (1, {'@': 975})}, 1790: {6: (1, {'@': 947}), 60: (1, {'@': 947}), 7: (1, {'@': 947}), 61: (1, {'@': 947}), 126: (1, {'@': 947}), 45: (1, {'@': 947}), 37: (1, {'@': 947}), 38: (1, {'@': 947}), 47: (1, {'@': 947}), 26: (1, {'@': 947}), 27: (1, {'@': 947}), 4: (1, {'@': 947}), 28: (1, {'@': 947}), 50: (1, {'@': 947}), 57: (1, {'@': 947})}, 1791: {400: (0, 1799), 126: (0, 181), 401: (0, 280)}, 1792: {112: (0, 1002)}, 1793: {112: (0, 2591)}, 1794: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 86: (0, 422), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 194: (0, 424), 120: (0, 840), 106: (0, 838), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 1795: {57: (1, {'@': 1333}), 60: (1, {'@': 1333})}, 1796: {1: (1, {'@': 976}), 6: (1, {'@': 976}), 60: (1, {'@': 976}), 61: (1, {'@': 976}), 126: (1, {'@': 976}), 45: (1, {'@': 976}), 38: (1, {'@': 976}), 26: (1, {'@': 976}), 27: (1, {'@': 976}), 28: (1, {'@': 976}), 57: (1, {'@': 976})}, 1797: {112: (0, 2563)}, 1798: {1: (1, {'@': 981}), 6: (1, {'@': 981}), 60: (1, {'@': 981}), 61: (1, {'@': 981}), 126: (1, {'@': 981}), 45: (1, {'@': 981}), 38: (1, {'@': 981}), 26: (1, {'@': 981}), 27: (1, {'@': 981}), 28: (1, {'@': 981}), 57: (1, {'@': 981})}, 1799: {112: (0, 240)}, 1800: {126: (1, {'@': 1738}), 60: (1, {'@': 1738})}, 1801: {60: (1, {'@': 786}), 57: (1, {'@': 786})}, 1802: {60: (1, {'@': 935}), 57: (1, {'@': 935})}, 1803: {1: (1, {'@': 980}), 6: (1, {'@': 980}), 60: (1, {'@': 980}), 61: (1, {'@': 980}), 126: (1, {'@': 980}), 45: (1, {'@': 980}), 38: (1, {'@': 980}), 26: (1, {'@': 980}), 27: (1, {'@': 980}), 28: (1, {'@': 980}), 57: (1, {'@': 980})}, 1804: {146: (0, 1690)}, 1805: {620: (0, 763), 622: (0, 1300)}, 1806: {515: (1, {'@': 1629}), 517: (1, {'@': 1629}), 60: (1, {'@': 1629}), 126: (1, {'@': 1629}), 514: (1, {'@': 1629}), 57: (1, {'@': 1629})}, 1807: {6: (1, {'@': 945}), 60: (1, {'@': 945}), 7: (1, {'@': 945}), 61: (1, {'@': 945}), 126: (1, {'@': 945}), 45: (1, {'@': 945}), 37: (1, {'@': 945}), 38: (1, {'@': 945}), 47: (1, {'@': 945}), 26: (1, {'@': 945}), 27: (1, {'@': 945}), 4: (1, {'@': 945}), 28: (1, {'@': 945}), 50: (1, {'@': 945}), 57: (1, {'@': 945})}, 1808: {1: (1, {'@': 978}), 6: (1, {'@': 978}), 60: (1, {'@': 978}), 61: (1, {'@': 978}), 126: (1, {'@': 978}), 45: (1, {'@': 978}), 38: (1, {'@': 978}), 26: (1, {'@': 978}), 27: (1, {'@': 978}), 28: (1, {'@': 978}), 57: (1, {'@': 978})}, 1809: {126: (0, 288), 193: (0, 53), 192: (0, 292), 60: (1, {'@': 771}), 57: (1, {'@': 771})}, 1810: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 86: (0, 1306), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1811: {112: (0, 2570)}, 1812: {112: (0, 168)}, 1813: {6: (1, {'@': 941}), 60: (1, {'@': 941}), 7: (1, {'@': 941}), 61: (1, {'@': 941}), 126: (1, {'@': 941}), 45: (1, {'@': 941}), 37: (1, {'@': 941}), 38: (1, {'@': 941}), 47: (1, {'@': 941}), 26: (1, {'@': 941}), 27: (1, {'@': 941}), 4: (1, {'@': 941}), 28: (1, {'@': 941}), 50: (1, {'@': 941}), 57: (1, {'@': 941})}, 1814: {453: (0, 249), 452: (0, 1821), 126: (0, 294)}, 1815: {661: (0, 776), 662: (0, 779), 663: (0, 1463), 664: (0, 2236)}, 1816: {60: (0, 2393)}, 1817: {6: (1, {'@': 940}), 60: (1, {'@': 940}), 7: (1, {'@': 940}), 61: (1, {'@': 940}), 126: (1, {'@': 940}), 45: (1, {'@': 940}), 37: (1, {'@': 940}), 38: (1, {'@': 940}), 47: (1, {'@': 940}), 26: (1, {'@': 940}), 27: (1, {'@': 940}), 4: (1, {'@': 940}), 28: (1, {'@': 940}), 50: (1, {'@': 940}), 57: (1, {'@': 940})}, 1818: {60: (1, {'@': 687})}, 1819: {177: (1, {'@': 597}), 7: (1, {'@': 597}), 22: (1, {'@': 597}), 60: (1, {'@': 597}), 126: (1, {'@': 597}), 48: (1, {'@': 597}), 72: (1, {'@': 597}), 178: (1, {'@': 597}), 179: (1, {'@': 597}), 49: (1, {'@': 597}), 57: (1, {'@': 597})}, 1820: {112: (0, 2557), 6: (1, {'@': 953}), 60: (1, {'@': 953}), 7: (1, {'@': 953}), 61: (1, {'@': 953}), 126: (1, {'@': 953}), 45: (1, {'@': 953}), 37: (1, {'@': 953}), 38: (1, {'@': 953}), 47: (1, {'@': 953}), 26: (1, {'@': 953}), 27: (1, {'@': 953}), 4: (1, {'@': 953}), 28: (1, {'@': 953}), 50: (1, {'@': 953}), 57: (1, {'@': 953}), 43: (1, {'@': 953}), 1: (1, {'@': 953}), 2: (1, {'@': 953}), 44: (1, {'@': 953}), 48: (1, {'@': 953}), 49: (1, {'@': 953}), 51: (1, {'@': 953}), 52: (1, {'@': 953}), 8: (1, {'@': 953}), 9: (1, {'@': 953}), 53: (1, {'@': 953}), 11: (1, {'@': 953}), 54: (1, {'@': 953}), 55: (1, {'@': 953}), 15: (1, {'@': 953}), 17: (1, {'@': 953}), 18: (1, {'@': 953}), 58: (1, {'@': 953}), 59: (1, {'@': 953}), 21: (1, {'@': 953}), 22: (1, {'@': 953}), 62: (1, {'@': 953}), 23: (1, {'@': 953}), 25: (1, {'@': 953}), 63: (1, {'@': 953}), 29: (1, {'@': 953}), 30: (1, {'@': 953}), 31: (1, {'@': 953}), 33: (1, {'@': 953}), 64: (1, {'@': 953}), 66: (1, {'@': 953}), 67: (1, {'@': 953}), 34: (1, {'@': 953}), 36: (1, {'@': 953}), 68: (1, {'@': 953}), 69: (1, {'@': 953}), 70: (1, {'@': 953}), 71: (1, {'@': 953}), 40: (1, {'@': 953}), 72: (1, {'@': 953}), 41: (1, {'@': 953}), 73: (1, {'@': 953}), 74: (1, {'@': 953}), 75: (1, {'@': 953})}, 1821: {112: (0, 286)}, 1822: {60: (1, {'@': 770}), 57: (1, {'@': 770})}, 1823: {126: (0, 1058), 60: (1, {'@': 579})}, 1824: {6: (1, {'@': 948}), 60: (1, {'@': 948}), 7: (1, {'@': 948}), 61: (1, {'@': 948}), 126: (1, {'@': 948}), 45: (1, {'@': 948}), 37: (1, {'@': 948}), 38: (1, {'@': 948}), 47: (1, {'@': 948}), 26: (1, {'@': 948}), 27: (1, {'@': 948}), 4: (1, {'@': 948}), 28: (1, {'@': 948}), 50: (1, {'@': 948}), 57: (1, {'@': 948})}, 1825: {57: (1, {'@': 1067}), 60: (1, {'@': 1067}), 62: (1, {'@': 1067}), 22: (1, {'@': 1067}), 126: (1, {'@': 1067}), 53: (1, {'@': 1067})}, 1826: {59: (1, {'@': 1513}), 60: (1, {'@': 1513}), 21: (1, {'@': 1513}), 22: (1, {'@': 1513}), 44: (1, {'@': 1513}), 126: (1, {'@': 1513}), 62: (1, {'@': 1513}), 61: (1, {'@': 1513}), 23: (1, {'@': 1513}), 25: (1, {'@': 1513}), 28: (1, {'@': 1513}), 49: (1, {'@': 1513}), 6: (1, {'@': 1513}), 33: (1, {'@': 1513}), 7: (1, {'@': 1513}), 53: (1, {'@': 1513}), 69: (1, {'@': 1513}), 40: (1, {'@': 1513}), 41: (1, {'@': 1513}), 75: (1, {'@': 1513}), 73: (1, {'@': 1513}), 57: (1, {'@': 1513}), 43: (1, {'@': 1513}), 1: (1, {'@': 1513}), 2: (1, {'@': 1513}), 45: (1, {'@': 1513}), 47: (1, {'@': 1513}), 48: (1, {'@': 1513}), 4: (1, {'@': 1513}), 50: (1, {'@': 1513}), 51: (1, {'@': 1513}), 52: (1, {'@': 1513}), 8: (1, {'@': 1513}), 9: (1, {'@': 1513}), 11: (1, {'@': 1513}), 54: (1, {'@': 1513}), 55: (1, {'@': 1513}), 15: (1, {'@': 1513}), 17: (1, {'@': 1513}), 18: (1, {'@': 1513}), 58: (1, {'@': 1513}), 26: (1, {'@': 1513}), 63: (1, {'@': 1513}), 27: (1, {'@': 1513}), 29: (1, {'@': 1513}), 30: (1, {'@': 1513}), 31: (1, {'@': 1513}), 64: (1, {'@': 1513}), 66: (1, {'@': 1513}), 67: (1, {'@': 1513}), 34: (1, {'@': 1513}), 36: (1, {'@': 1513}), 37: (1, {'@': 1513}), 68: (1, {'@': 1513}), 38: (1, {'@': 1513}), 70: (1, {'@': 1513}), 71: (1, {'@': 1513}), 72: (1, {'@': 1513}), 74: (1, {'@': 1513})}, 1827: {57: (1, {'@': 1129}), 60: (1, {'@': 1129}), 59: (1, {'@': 1129}), 7: (1, {'@': 1129}), 22: (1, {'@': 1129}), 34: (1, {'@': 1129}), 53: (1, {'@': 1129}), 126: (1, {'@': 1129}), 69: (1, {'@': 1129}), 49: (1, {'@': 1129})}, 1828: {112: (0, 2574)}, 1829: {22: (0, 389), 126: (0, 271), 53: (0, 387), 205: (0, 1825), 62: (0, 367), 447: (0, 312), 206: (0, 1838), 172: (0, 1841), 57: (1, {'@': 1066}), 60: (1, {'@': 1066})}, 1830: {146: (1, {'@': 409}), 126: (1, {'@': 1367}), 53: (1, {'@': 1367}), 57: (1, {'@': 1367}), 60: (1, {'@': 1367})}, 1831: {22: (0, 389), 48: (0, 1843), 7: (0, 45), 665: (0, 165), 390: (0, 1819), 177: (0, 1812), 49: (0, 335), 391: (0, 1837), 179: (0, 1835), 206: (0, 1935), 198: (0, 1940), 72: (0, 1882), 393: (0, 178), 392: (0, 1945), 178: (0, 1950), 126: (0, 179), 180: (0, 1955), 394: (0, 1961), 395: (0, 1966), 60: (1, {'@': 590}), 57: (1, {'@': 590})}, 1832: {515: (1, {'@': 586}), 517: (1, {'@': 586}), 60: (1, {'@': 586}), 126: (1, {'@': 586}), 514: (1, {'@': 586}), 57: (1, {'@': 586})}, 1833: {112: (0, 1728)}, 1834: {144: (0, 2316), 145: (0, 1040)}, 1835: {112: (0, 170)}, 1836: {6: (1, {'@': 943}), 60: (1, {'@': 943}), 7: (1, {'@': 943}), 61: (1, {'@': 943}), 126: (1, {'@': 943}), 45: (1, {'@': 943}), 37: (1, {'@': 943}), 38: (1, {'@': 943}), 47: (1, {'@': 943}), 26: (1, {'@': 943}), 27: (1, {'@': 943}), 4: (1, {'@': 943}), 28: (1, {'@': 943}), 50: (1, {'@': 943}), 57: (1, {'@': 943})}, 1837: {177: (1, {'@': 593}), 7: (1, {'@': 593}), 22: (1, {'@': 593}), 60: (1, {'@': 593}), 126: (1, {'@': 593}), 48: (1, {'@': 593}), 72: (1, {'@': 593}), 178: (1, {'@': 593}), 179: (1, {'@': 593}), 49: (1, {'@': 593}), 57: (1, {'@': 593})}, 1838: {57: (1, {'@': 1068}), 60: (1, {'@': 1068}), 62: (1, {'@': 1068}), 22: (1, {'@': 1068}), 126: (1, {'@': 1068}), 53: (1, {'@': 1068})}, 1839: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 86: (0, 2259), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 1840: {57: (1, {'@': 1154}), 60: (1, {'@': 1154}), 48: (1, {'@': 1154}), 49: (1, {'@': 1154}), 6: (1, {'@': 1154}), 7: (1, {'@': 1154}), 9: (1, {'@': 1154}), 53: (1, {'@': 1154}), 58: (1, {'@': 1154}), 59: (1, {'@': 1154}), 22: (1, {'@': 1154}), 61: (1, {'@': 1154}), 126: (1, {'@': 1154}), 28: (1, {'@': 1154}), 31: (1, {'@': 1154}), 33: (1, {'@': 1154}), 34: (1, {'@': 1154}), 36: (1, {'@': 1154}), 69: (1, {'@': 1154}), 72: (1, {'@': 1154}), 75: (1, {'@': 1154})}, 1841: {57: (1, {'@': 1069}), 60: (1, {'@': 1069}), 62: (1, {'@': 1069}), 22: (1, {'@': 1069}), 126: (1, {'@': 1069}), 53: (1, {'@': 1069})}, 1842: {6: (1, {'@': 946}), 60: (1, {'@': 946}), 7: (1, {'@': 946}), 61: (1, {'@': 946}), 126: (1, {'@': 946}), 45: (1, {'@': 946}), 37: (1, {'@': 946}), 38: (1, {'@': 946}), 47: (1, {'@': 946}), 26: (1, {'@': 946}), 27: (1, {'@': 946}), 4: (1, {'@': 946}), 28: (1, {'@': 946}), 50: (1, {'@': 946}), 57: (1, {'@': 946})}, 1843: {112: (0, 1758)}, 1844: {57: (1, {'@': 1146}), 60: (1, {'@': 1146}), 48: (1, {'@': 1146}), 49: (1, {'@': 1146}), 6: (1, {'@': 1146}), 7: (1, {'@': 1146}), 9: (1, {'@': 1146}), 53: (1, {'@': 1146}), 58: (1, {'@': 1146}), 59: (1, {'@': 1146}), 22: (1, {'@': 1146}), 61: (1, {'@': 1146}), 126: (1, {'@': 1146}), 28: (1, {'@': 1146}), 31: (1, {'@': 1146}), 33: (1, {'@': 1146}), 34: (1, {'@': 1146}), 36: (1, {'@': 1146}), 69: (1, {'@': 1146}), 72: (1, {'@': 1146}), 75: (1, {'@': 1146})}, 1845: {60: (1, {'@': 1339}), 57: (1, {'@': 1339})}, 1846: {6: (1, {'@': 949}), 60: (1, {'@': 949}), 7: (1, {'@': 949}), 61: (1, {'@': 949}), 126: (1, {'@': 949}), 45: (1, {'@': 949}), 37: (1, {'@': 949}), 38: (1, {'@': 949}), 47: (1, {'@': 949}), 26: (1, {'@': 949}), 27: (1, {'@': 949}), 4: (1, {'@': 949}), 28: (1, {'@': 949}), 50: (1, {'@': 949}), 57: (1, {'@': 949})}, 1847: {57: (1, {'@': 1145}), 60: (1, {'@': 1145}), 48: (1, {'@': 1145}), 49: (1, {'@': 1145}), 6: (1, {'@': 1145}), 7: (1, {'@': 1145}), 9: (1, {'@': 1145}), 53: (1, {'@': 1145}), 58: (1, {'@': 1145}), 59: (1, {'@': 1145}), 22: (1, {'@': 1145}), 61: (1, {'@': 1145}), 126: (1, {'@': 1145}), 28: (1, {'@': 1145}), 31: (1, {'@': 1145}), 33: (1, {'@': 1145}), 34: (1, {'@': 1145}), 36: (1, {'@': 1145}), 69: (1, {'@': 1145}), 72: (1, {'@': 1145}), 75: (1, {'@': 1145})}, 1848: {387: (0, 1852), 388: (0, 345), 126: (0, 149), 60: (1, {'@': 1342}), 57: (1, {'@': 1342})}, 1849: {6: (1, {'@': 939}), 60: (1, {'@': 939}), 7: (1, {'@': 939}), 61: (1, {'@': 939}), 126: (1, {'@': 939}), 45: (1, {'@': 939}), 37: (1, {'@': 939}), 38: (1, {'@': 939}), 47: (1, {'@': 939}), 26: (1, {'@': 939}), 27: (1, {'@': 939}), 4: (1, {'@': 939}), 28: (1, {'@': 939}), 50: (1, {'@': 939}), 57: (1, {'@': 939})}, 1850: {57: (1, {'@': 1153}), 60: (1, {'@': 1153}), 48: (1, {'@': 1153}), 49: (1, {'@': 1153}), 6: (1, {'@': 1153}), 7: (1, {'@': 1153}), 9: (1, {'@': 1153}), 53: (1, {'@': 1153}), 58: (1, {'@': 1153}), 59: (1, {'@': 1153}), 22: (1, {'@': 1153}), 61: (1, {'@': 1153}), 126: (1, {'@': 1153}), 28: (1, {'@': 1153}), 31: (1, {'@': 1153}), 33: (1, {'@': 1153}), 34: (1, {'@': 1153}), 36: (1, {'@': 1153}), 69: (1, {'@': 1153}), 72: (1, {'@': 1153}), 75: (1, {'@': 1153})}, 1851: {112: (0, 2399)}, 1852: {112: (0, 157), 57: (1, {'@': 1355}), 60: (1, {'@': 1355}), 470: (1, {'@': 1355}), 126: (1, {'@': 1355})}, 1853: {6: (1, {'@': 942}), 60: (1, {'@': 942}), 7: (1, {'@': 942}), 61: (1, {'@': 942}), 126: (1, {'@': 942}), 45: (1, {'@': 942}), 37: (1, {'@': 942}), 38: (1, {'@': 942}), 47: (1, {'@': 942}), 26: (1, {'@': 942}), 27: (1, {'@': 942}), 4: (1, {'@': 942}), 28: (1, {'@': 942}), 50: (1, {'@': 942}), 57: (1, {'@': 942})}, 1854: {57: (1, {'@': 1149}), 60: (1, {'@': 1149}), 48: (1, {'@': 1149}), 49: (1, {'@': 1149}), 6: (1, {'@': 1149}), 7: (1, {'@': 1149}), 9: (1, {'@': 1149}), 53: (1, {'@': 1149}), 58: (1, {'@': 1149}), 59: (1, {'@': 1149}), 22: (1, {'@': 1149}), 61: (1, {'@': 1149}), 126: (1, {'@': 1149}), 28: (1, {'@': 1149}), 31: (1, {'@': 1149}), 33: (1, {'@': 1149}), 34: (1, {'@': 1149}), 36: (1, {'@': 1149}), 69: (1, {'@': 1149}), 72: (1, {'@': 1149}), 75: (1, {'@': 1149})}, 1855: {1: (1, {'@': 984}), 6: (1, {'@': 984}), 60: (1, {'@': 984}), 61: (1, {'@': 984}), 126: (1, {'@': 984}), 45: (1, {'@': 984}), 38: (1, {'@': 984}), 26: (1, {'@': 984}), 27: (1, {'@': 984}), 28: (1, {'@': 984}), 57: (1, {'@': 984}), 43: (1, {'@': 984}), 2: (1, {'@': 984}), 44: (1, {'@': 984}), 47: (1, {'@': 984}), 48: (1, {'@': 984}), 4: (1, {'@': 984}), 49: (1, {'@': 984}), 50: (1, {'@': 984}), 51: (1, {'@': 984}), 52: (1, {'@': 984}), 8: (1, {'@': 984}), 7: (1, {'@': 984}), 9: (1, {'@': 984}), 53: (1, {'@': 984}), 11: (1, {'@': 984}), 54: (1, {'@': 984}), 55: (1, {'@': 984}), 15: (1, {'@': 984}), 17: (1, {'@': 984}), 18: (1, {'@': 984}), 58: (1, {'@': 984}), 59: (1, {'@': 984}), 21: (1, {'@': 984}), 22: (1, {'@': 984}), 62: (1, {'@': 984}), 23: (1, {'@': 984}), 25: (1, {'@': 984}), 63: (1, {'@': 984}), 29: (1, {'@': 984}), 30: (1, {'@': 984}), 31: (1, {'@': 984}), 33: (1, {'@': 984}), 64: (1, {'@': 984}), 66: (1, {'@': 984}), 67: (1, {'@': 984}), 34: (1, {'@': 984}), 36: (1, {'@': 984}), 37: (1, {'@': 984}), 68: (1, {'@': 984}), 69: (1, {'@': 984}), 70: (1, {'@': 984}), 71: (1, {'@': 984}), 40: (1, {'@': 984}), 72: (1, {'@': 984}), 41: (1, {'@': 984}), 73: (1, {'@': 984}), 74: (1, {'@': 984}), 75: (1, {'@': 984})}, 1856: {434: (0, 1214), 436: (0, 1217), 563: (0, 2254), 438: (0, 1230), 432: (0, 1242), 562: (0, 1245), 439: (0, 1253)}, 1857: {6: (1, {'@': 950}), 60: (1, {'@': 950}), 7: (1, {'@': 950}), 61: (1, {'@': 950}), 126: (1, {'@': 950}), 45: (1, {'@': 950}), 37: (1, {'@': 950}), 38: (1, {'@': 950}), 47: (1, {'@': 950}), 26: (1, {'@': 950}), 27: (1, {'@': 950}), 4: (1, {'@': 950}), 28: (1, {'@': 950}), 50: (1, {'@': 950}), 57: (1, {'@': 950})}, 1858: {57: (1, {'@': 1157}), 60: (1, {'@': 1157}), 48: (1, {'@': 1157}), 49: (1, {'@': 1157}), 6: (1, {'@': 1157}), 7: (1, {'@': 1157}), 9: (1, {'@': 1157}), 53: (1, {'@': 1157}), 58: (1, {'@': 1157}), 59: (1, {'@': 1157}), 22: (1, {'@': 1157}), 61: (1, {'@': 1157}), 126: (1, {'@': 1157}), 28: (1, {'@': 1157}), 31: (1, {'@': 1157}), 33: (1, {'@': 1157}), 34: (1, {'@': 1157}), 36: (1, {'@': 1157}), 69: (1, {'@': 1157}), 72: (1, {'@': 1157}), 75: (1, {'@': 1157})}, 1859: {6: (1, {'@': 1427}), 60: (1, {'@': 1427}), 7: (1, {'@': 1427}), 61: (1, {'@': 1427}), 126: (1, {'@': 1427}), 28: (1, {'@': 1427}), 17: (1, {'@': 1427}), 57: (1, {'@': 1427}), 59: (1, {'@': 1427}), 21: (1, {'@': 1427}), 22: (1, {'@': 1427}), 44: (1, {'@': 1427}), 62: (1, {'@': 1427}), 23: (1, {'@': 1427}), 25: (1, {'@': 1427}), 49: (1, {'@': 1427}), 33: (1, {'@': 1427}), 53: (1, {'@': 1427}), 69: (1, {'@': 1427}), 40: (1, {'@': 1427}), 41: (1, {'@': 1427}), 75: (1, {'@': 1427}), 73: (1, {'@': 1427}), 45: (1, {'@': 1427}), 37: (1, {'@': 1427}), 38: (1, {'@': 1427}), 47: (1, {'@': 1427}), 26: (1, {'@': 1427}), 27: (1, {'@': 1427}), 4: (1, {'@': 1427}), 50: (1, {'@': 1427}), 43: (1, {'@': 1427}), 64: (1, {'@': 1427}), 34: (1, {'@': 1427}), 54: (1, {'@': 1427}), 74: (1, {'@': 1427}), 18: (1, {'@': 1427}), 58: (1, {'@': 1427}), 66: (1, {'@': 1427}), 1: (1, {'@': 1427}), 2: (1, {'@': 1427}), 63: (1, {'@': 1427}), 52: (1, {'@': 1427}), 8: (1, {'@': 1427}), 71: (1, {'@': 1427}), 55: (1, {'@': 1427}), 48: (1, {'@': 1427}), 51: (1, {'@': 1427}), 9: (1, {'@': 1427}), 11: (1, {'@': 1427}), 15: (1, {'@': 1427}), 29: (1, {'@': 1427}), 30: (1, {'@': 1427}), 31: (1, {'@': 1427}), 67: (1, {'@': 1427}), 36: (1, {'@': 1427}), 68: (1, {'@': 1427}), 70: (1, {'@': 1427}), 72: (1, {'@': 1427})}, 1860: {144: (0, 2247)}, 1861: {57: (1, {'@': 1148}), 60: (1, {'@': 1148}), 48: (1, {'@': 1148}), 49: (1, {'@': 1148}), 6: (1, {'@': 1148}), 7: (1, {'@': 1148}), 9: (1, {'@': 1148}), 53: (1, {'@': 1148}), 58: (1, {'@': 1148}), 59: (1, {'@': 1148}), 22: (1, {'@': 1148}), 61: (1, {'@': 1148}), 126: (1, {'@': 1148}), 28: (1, {'@': 1148}), 31: (1, {'@': 1148}), 33: (1, {'@': 1148}), 34: (1, {'@': 1148}), 36: (1, {'@': 1148}), 69: (1, {'@': 1148}), 72: (1, {'@': 1148}), 75: (1, {'@': 1148})}, 1862: {112: (0, 147), 57: (1, {'@': 1358}), 60: (1, {'@': 1358}), 126: (1, {'@': 1358}), 387: (1, {'@': 1358})}, 1863: {60: (0, 2250)}, 1864: {470: (0, 1862), 471: (0, 137), 126: (0, 323), 60: (1, {'@': 1341}), 57: (1, {'@': 1341})}, 1865: {57: (1, {'@': 1151}), 60: (1, {'@': 1151}), 48: (1, {'@': 1151}), 49: (1, {'@': 1151}), 6: (1, {'@': 1151}), 7: (1, {'@': 1151}), 9: (1, {'@': 1151}), 53: (1, {'@': 1151}), 58: (1, {'@': 1151}), 59: (1, {'@': 1151}), 22: (1, {'@': 1151}), 61: (1, {'@': 1151}), 126: (1, {'@': 1151}), 28: (1, {'@': 1151}), 31: (1, {'@': 1151}), 33: (1, {'@': 1151}), 34: (1, {'@': 1151}), 36: (1, {'@': 1151}), 69: (1, {'@': 1151}), 72: (1, {'@': 1151}), 75: (1, {'@': 1151})}, 1866: {57: (1, {'@': 549}), 60: (1, {'@': 549})}, 1867: {57: (1, {'@': 877}), 60: (1, {'@': 877}), 61: (1, {'@': 877}), 53: (1, {'@': 877}), 67: (1, {'@': 877}), 126: (1, {'@': 877}), 37: (1, {'@': 877}), 45: (1, {'@': 877}), 38: (1, {'@': 877}), 26: (1, {'@': 877}), 27: (1, {'@': 877}), 4: (1, {'@': 877}), 29: (1, {'@': 877}), 30: (1, {'@': 877}), 15: (1, {'@': 877})}, 1868: {60: (1, {'@': 1338}), 57: (1, {'@': 1338})}, 1869: {126: (1, {'@': 1603}), 60: (1, {'@': 1603})}, 1870: {112: (0, 2599)}, 1871: {57: (1, {'@': 1152}), 60: (1, {'@': 1152}), 48: (1, {'@': 1152}), 49: (1, {'@': 1152}), 6: (1, {'@': 1152}), 7: (1, {'@': 1152}), 9: (1, {'@': 1152}), 53: (1, {'@': 1152}), 58: (1, {'@': 1152}), 59: (1, {'@': 1152}), 22: (1, {'@': 1152}), 61: (1, {'@': 1152}), 126: (1, {'@': 1152}), 28: (1, {'@': 1152}), 31: (1, {'@': 1152}), 33: (1, {'@': 1152}), 34: (1, {'@': 1152}), 36: (1, {'@': 1152}), 69: (1, {'@': 1152}), 72: (1, {'@': 1152}), 75: (1, {'@': 1152})}, 1872: {60: (1, {'@': 1015}), 21: (1, {'@': 1015}), 22: (1, {'@': 1015}), 44: (1, {'@': 1015}), 126: (1, {'@': 1015}), 62: (1, {'@': 1015}), 61: (1, {'@': 1015}), 28: (1, {'@': 1015}), 33: (1, {'@': 1015}), 6: (1, {'@': 1015}), 64: (1, {'@': 1015}), 34: (1, {'@': 1015}), 53: (1, {'@': 1015}), 54: (1, {'@': 1015}), 69: (1, {'@': 1015}), 40: (1, {'@': 1015}), 73: (1, {'@': 1015}), 75: (1, {'@': 1015}), 57: (1, {'@': 1015}), 18: (1, {'@': 1015})}, 1873: {59: (1, {'@': 1496}), 60: (1, {'@': 1496}), 21: (1, {'@': 1496}), 22: (1, {'@': 1496}), 44: (1, {'@': 1496}), 126: (1, {'@': 1496}), 62: (1, {'@': 1496}), 61: (1, {'@': 1496}), 23: (1, {'@': 1496}), 25: (1, {'@': 1496}), 28: (1, {'@': 1496}), 49: (1, {'@': 1496}), 6: (1, {'@': 1496}), 33: (1, {'@': 1496}), 7: (1, {'@': 1496}), 53: (1, {'@': 1496}), 69: (1, {'@': 1496}), 40: (1, {'@': 1496}), 41: (1, {'@': 1496}), 75: (1, {'@': 1496}), 73: (1, {'@': 1496}), 57: (1, {'@': 1496}), 43: (1, {'@': 1496}), 45: (1, {'@': 1496}), 27: (1, {'@': 1496}), 64: (1, {'@': 1496}), 34: (1, {'@': 1496}), 37: (1, {'@': 1496}), 54: (1, {'@': 1496}), 38: (1, {'@': 1496}), 74: (1, {'@': 1496}), 18: (1, {'@': 1496}), 1: (1, {'@': 1496}), 2: (1, {'@': 1496}), 47: (1, {'@': 1496}), 48: (1, {'@': 1496}), 4: (1, {'@': 1496}), 50: (1, {'@': 1496}), 51: (1, {'@': 1496}), 52: (1, {'@': 1496}), 8: (1, {'@': 1496}), 9: (1, {'@': 1496}), 11: (1, {'@': 1496}), 55: (1, {'@': 1496}), 15: (1, {'@': 1496}), 17: (1, {'@': 1496}), 58: (1, {'@': 1496}), 26: (1, {'@': 1496}), 63: (1, {'@': 1496}), 29: (1, {'@': 1496}), 30: (1, {'@': 1496}), 31: (1, {'@': 1496}), 66: (1, {'@': 1496}), 67: (1, {'@': 1496}), 36: (1, {'@': 1496}), 68: (1, {'@': 1496}), 70: (1, {'@': 1496}), 71: (1, {'@': 1496}), 72: (1, {'@': 1496})}, 1874: {57: (1, {'@': 883}), 60: (1, {'@': 883}), 61: (1, {'@': 883}), 53: (1, {'@': 883}), 67: (1, {'@': 883}), 126: (1, {'@': 883}), 37: (1, {'@': 883}), 45: (1, {'@': 883}), 38: (1, {'@': 883}), 26: (1, {'@': 883}), 27: (1, {'@': 883}), 4: (1, {'@': 883}), 29: (1, {'@': 883}), 30: (1, {'@': 883}), 15: (1, {'@': 883})}, 1875: {200: (0, 1840), 22: (0, 389), 48: (0, 1843), 53: (0, 387), 58: (0, 1666), 33: (0, 383), 183: (0, 1844), 7: (0, 45), 197: (0, 1847), 164: (0, 1850), 397: (0, 172), 59: (0, 363), 208: (0, 1854), 396: (0, 1858), 75: (0, 341), 36: (0, 15), 49: (0, 335), 172: (0, 1861), 28: (0, 33), 212: (0, 1865), 180: (0, 1871), 34: (0, 1589), 61: (0, 25), 72: (0, 1882), 206: (0, 1884), 69: (0, 1760), 126: (0, 173), 204: (0, 1887), 198: (0, 1891), 296: (0, 1896), 6: (0, 20), 31: (0, 1901), 9: (0, 1906), 392: (0, 1911), 185: (0, 1918), 395: (0, 1921), 398: (0, 1926), 287: (0, 1931), 60: (1, {'@': 1139}), 57: (1, {'@': 1139})}, 1876: {60: (1, {'@': 1018}), 21: (1, {'@': 1018}), 22: (1, {'@': 1018}), 44: (1, {'@': 1018}), 126: (1, {'@': 1018}), 62: (1, {'@': 1018}), 61: (1, {'@': 1018}), 28: (1, {'@': 1018}), 33: (1, {'@': 1018}), 6: (1, {'@': 1018}), 64: (1, {'@': 1018}), 34: (1, {'@': 1018}), 53: (1, {'@': 1018}), 54: (1, {'@': 1018}), 69: (1, {'@': 1018}), 40: (1, {'@': 1018}), 73: (1, {'@': 1018}), 75: (1, {'@': 1018}), 57: (1, {'@': 1018}), 18: (1, {'@': 1018})}, 1877: {60: (0, 2266)}, 1878: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 2281), 112: (0, 2376), 97: (0, 2370)}, 1879: {57: (1, {'@': 879}), 60: (1, {'@': 879}), 61: (1, {'@': 879}), 53: (1, {'@': 879}), 67: (1, {'@': 879}), 126: (1, {'@': 879}), 37: (1, {'@': 879}), 45: (1, {'@': 879}), 38: (1, {'@': 879}), 26: (1, {'@': 879}), 27: (1, {'@': 879}), 4: (1, {'@': 879}), 29: (1, {'@': 879}), 30: (1, {'@': 879}), 15: (1, {'@': 879})}, 1880: {60: (1, {'@': 1014}), 21: (1, {'@': 1014}), 22: (1, {'@': 1014}), 44: (1, {'@': 1014}), 126: (1, {'@': 1014}), 62: (1, {'@': 1014}), 61: (1, {'@': 1014}), 28: (1, {'@': 1014}), 33: (1, {'@': 1014}), 6: (1, {'@': 1014}), 64: (1, {'@': 1014}), 34: (1, {'@': 1014}), 53: (1, {'@': 1014}), 54: (1, {'@': 1014}), 69: (1, {'@': 1014}), 40: (1, {'@': 1014}), 73: (1, {'@': 1014}), 75: (1, {'@': 1014}), 57: (1, {'@': 1014}), 18: (1, {'@': 1014})}, 1881: {57: (1, {'@': 880}), 60: (1, {'@': 880}), 61: (1, {'@': 880}), 53: (1, {'@': 880}), 67: (1, {'@': 880}), 126: (1, {'@': 880}), 37: (1, {'@': 880}), 45: (1, {'@': 880}), 38: (1, {'@': 880}), 26: (1, {'@': 880}), 27: (1, {'@': 880}), 4: (1, {'@': 880}), 29: (1, {'@': 880}), 30: (1, {'@': 880}), 15: (1, {'@': 880})}, 1882: {112: (0, 151)}, 1883: {60: (1, {'@': 1019}), 21: (1, {'@': 1019}), 22: (1, {'@': 1019}), 44: (1, {'@': 1019}), 126: (1, {'@': 1019}), 62: (1, {'@': 1019}), 61: (1, {'@': 1019}), 28: (1, {'@': 1019}), 33: (1, {'@': 1019}), 6: (1, {'@': 1019}), 64: (1, {'@': 1019}), 34: (1, {'@': 1019}), 53: (1, {'@': 1019}), 54: (1, {'@': 1019}), 69: (1, {'@': 1019}), 40: (1, {'@': 1019}), 73: (1, {'@': 1019}), 75: (1, {'@': 1019}), 57: (1, {'@': 1019}), 18: (1, {'@': 1019})}, 1884: {57: (1, {'@': 1143}), 60: (1, {'@': 1143}), 48: (1, {'@': 1143}), 49: (1, {'@': 1143}), 6: (1, {'@': 1143}), 7: (1, {'@': 1143}), 9: (1, {'@': 1143}), 53: (1, {'@': 1143}), 58: (1, {'@': 1143}), 59: (1, {'@': 1143}), 22: (1, {'@': 1143}), 61: (1, {'@': 1143}), 126: (1, {'@': 1143}), 28: (1, {'@': 1143}), 31: (1, {'@': 1143}), 33: (1, {'@': 1143}), 34: (1, {'@': 1143}), 36: (1, {'@': 1143}), 69: (1, {'@': 1143}), 72: (1, {'@': 1143}), 75: (1, {'@': 1143})}, 1885: {60: (1, {'@': 867}), 57: (1, {'@': 867})}, 1886: {60: (1, {'@': 1020}), 21: (1, {'@': 1020}), 22: (1, {'@': 1020}), 44: (1, {'@': 1020}), 126: (1, {'@': 1020}), 62: (1, {'@': 1020}), 61: (1, {'@': 1020}), 28: (1, {'@': 1020}), 33: (1, {'@': 1020}), 6: (1, {'@': 1020}), 64: (1, {'@': 1020}), 34: (1, {'@': 1020}), 53: (1, {'@': 1020}), 54: (1, {'@': 1020}), 69: (1, {'@': 1020}), 40: (1, {'@': 1020}), 73: (1, {'@': 1020}), 75: (1, {'@': 1020}), 57: (1, {'@': 1020}), 18: (1, {'@': 1020})}, 1887: {57: (1, {'@': 1141}), 60: (1, {'@': 1141}), 48: (1, {'@': 1141}), 49: (1, {'@': 1141}), 6: (1, {'@': 1141}), 7: (1, {'@': 1141}), 9: (1, {'@': 1141}), 53: (1, {'@': 1141}), 58: (1, {'@': 1141}), 59: (1, {'@': 1141}), 22: (1, {'@': 1141}), 61: (1, {'@': 1141}), 126: (1, {'@': 1141}), 28: (1, {'@': 1141}), 31: (1, {'@': 1141}), 33: (1, {'@': 1141}), 34: (1, {'@': 1141}), 36: (1, {'@': 1141}), 69: (1, {'@': 1141}), 72: (1, {'@': 1141}), 75: (1, {'@': 1141})}, 1888: {57: (1, {'@': 881}), 60: (1, {'@': 881}), 61: (1, {'@': 881}), 53: (1, {'@': 881}), 67: (1, {'@': 881}), 126: (1, {'@': 881}), 37: (1, {'@': 881}), 45: (1, {'@': 881}), 38: (1, {'@': 881}), 26: (1, {'@': 881}), 27: (1, {'@': 881}), 4: (1, {'@': 881}), 29: (1, {'@': 881}), 30: (1, {'@': 881}), 15: (1, {'@': 881})}, 1889: {60: (1, {'@': 1010}), 21: (1, {'@': 1010}), 22: (1, {'@': 1010}), 44: (1, {'@': 1010}), 126: (1, {'@': 1010}), 62: (1, {'@': 1010}), 61: (1, {'@': 1010}), 28: (1, {'@': 1010}), 33: (1, {'@': 1010}), 6: (1, {'@': 1010}), 64: (1, {'@': 1010}), 34: (1, {'@': 1010}), 53: (1, {'@': 1010}), 54: (1, {'@': 1010}), 69: (1, {'@': 1010}), 40: (1, {'@': 1010}), 73: (1, {'@': 1010}), 75: (1, {'@': 1010}), 57: (1, {'@': 1010}), 18: (1, {'@': 1010})}, 1890: {126: (1, {'@': 1644}), 60: (1, {'@': 1644})}, 1891: {57: (1, {'@': 1144}), 60: (1, {'@': 1144}), 48: (1, {'@': 1144}), 49: (1, {'@': 1144}), 6: (1, {'@': 1144}), 7: (1, {'@': 1144}), 9: (1, {'@': 1144}), 53: (1, {'@': 1144}), 58: (1, {'@': 1144}), 59: (1, {'@': 1144}), 22: (1, {'@': 1144}), 61: (1, {'@': 1144}), 126: (1, {'@': 1144}), 28: (1, {'@': 1144}), 31: (1, {'@': 1144}), 33: (1, {'@': 1144}), 34: (1, {'@': 1144}), 36: (1, {'@': 1144}), 69: (1, {'@': 1144}), 72: (1, {'@': 1144}), 75: (1, {'@': 1144})}, 1892: {6: (1, {'@': 954}), 60: (1, {'@': 954}), 7: (1, {'@': 954}), 61: (1, {'@': 954}), 126: (1, {'@': 954}), 45: (1, {'@': 954}), 37: (1, {'@': 954}), 38: (1, {'@': 954}), 47: (1, {'@': 954}), 26: (1, {'@': 954}), 27: (1, {'@': 954}), 4: (1, {'@': 954}), 28: (1, {'@': 954}), 50: (1, {'@': 954}), 57: (1, {'@': 954}), 43: (1, {'@': 954}), 1: (1, {'@': 954}), 2: (1, {'@': 954}), 44: (1, {'@': 954}), 48: (1, {'@': 954}), 49: (1, {'@': 954}), 51: (1, {'@': 954}), 52: (1, {'@': 954}), 8: (1, {'@': 954}), 9: (1, {'@': 954}), 53: (1, {'@': 954}), 11: (1, {'@': 954}), 54: (1, {'@': 954}), 55: (1, {'@': 954}), 15: (1, {'@': 954}), 17: (1, {'@': 954}), 18: (1, {'@': 954}), 58: (1, {'@': 954}), 59: (1, {'@': 954}), 21: (1, {'@': 954}), 22: (1, {'@': 954}), 62: (1, {'@': 954}), 23: (1, {'@': 954}), 25: (1, {'@': 954}), 63: (1, {'@': 954}), 29: (1, {'@': 954}), 30: (1, {'@': 954}), 31: (1, {'@': 954}), 33: (1, {'@': 954}), 64: (1, {'@': 954}), 66: (1, {'@': 954}), 67: (1, {'@': 954}), 34: (1, {'@': 954}), 36: (1, {'@': 954}), 68: (1, {'@': 954}), 69: (1, {'@': 954}), 70: (1, {'@': 954}), 71: (1, {'@': 954}), 40: (1, {'@': 954}), 72: (1, {'@': 954}), 41: (1, {'@': 954}), 73: (1, {'@': 954}), 74: (1, {'@': 954}), 75: (1, {'@': 954})}, 1893: {57: (1, {'@': 872}), 60: (1, {'@': 872}), 61: (1, {'@': 872}), 53: (1, {'@': 872}), 67: (1, {'@': 872}), 126: (1, {'@': 872}), 37: (1, {'@': 872}), 45: (1, {'@': 872}), 38: (1, {'@': 872}), 26: (1, {'@': 872}), 27: (1, {'@': 872}), 4: (1, {'@': 872}), 29: (1, {'@': 872}), 30: (1, {'@': 872}), 15: (1, {'@': 872})}, 1894: {22: (0, 389), 53: (0, 387), 18: (0, 1581), 172: (0, 1872), 33: (0, 383), 64: (0, 1537), 200: (0, 1876), 44: (0, 358), 183: (0, 1880), 62: (0, 367), 21: (0, 366), 164: (0, 1883), 666: (0, 333), 287: (0, 1886), 204: (0, 1889), 75: (0, 341), 476: (0, 338), 34: (0, 1589), 28: (0, 33), 126: (0, 340), 61: (0, 25), 208: (0, 1904), 205: (0, 1907), 207: (0, 1912), 280: (0, 1916), 213: (0, 1919), 54: (0, 1598), 283: (0, 1922), 40: (0, 1756), 69: (0, 1760), 185: (0, 1932), 211: (0, 1936), 210: (0, 1941), 206: (0, 1946), 73: (0, 1763), 6: (0, 20), 286: (0, 1951), 57: (1, {'@': 1007}), 60: (1, {'@': 1007})}, 1895: {57: (1, {'@': 1433}), 60: (1, {'@': 1433}), 6: (1, {'@': 1433}), 7: (1, {'@': 1433}), 61: (1, {'@': 1433}), 126: (1, {'@': 1433}), 45: (1, {'@': 1433}), 37: (1, {'@': 1433}), 38: (1, {'@': 1433}), 47: (1, {'@': 1433}), 26: (1, {'@': 1433}), 27: (1, {'@': 1433}), 4: (1, {'@': 1433}), 28: (1, {'@': 1433}), 50: (1, {'@': 1433}), 53: (1, {'@': 1433}), 67: (1, {'@': 1433}), 29: (1, {'@': 1433}), 30: (1, {'@': 1433}), 15: (1, {'@': 1433}), 43: (1, {'@': 1433}), 21: (1, {'@': 1433}), 44: (1, {'@': 1433}), 33: (1, {'@': 1433}), 64: (1, {'@': 1433}), 34: (1, {'@': 1433}), 54: (1, {'@': 1433}), 69: (1, {'@': 1433}), 40: (1, {'@': 1433}), 74: (1, {'@': 1433}), 41: (1, {'@': 1433}), 75: (1, {'@': 1433}), 18: (1, {'@': 1433}), 58: (1, {'@': 1433}), 66: (1, {'@': 1433}), 2: (1, {'@': 1433}), 63: (1, {'@': 1433}), 52: (1, {'@': 1433}), 8: (1, {'@': 1433}), 71: (1, {'@': 1433}), 55: (1, {'@': 1433}), 1: (1, {'@': 1433}), 48: (1, {'@': 1433}), 49: (1, {'@': 1433}), 51: (1, {'@': 1433}), 9: (1, {'@': 1433}), 11: (1, {'@': 1433}), 17: (1, {'@': 1433}), 59: (1, {'@': 1433}), 22: (1, {'@': 1433}), 62: (1, {'@': 1433}), 23: (1, {'@': 1433}), 25: (1, {'@': 1433}), 31: (1, {'@': 1433}), 36: (1, {'@': 1433}), 68: (1, {'@': 1433}), 70: (1, {'@': 1433}), 72: (1, {'@': 1433}), 73: (1, {'@': 1433})}, 1896: {57: (1, {'@': 1156}), 60: (1, {'@': 1156}), 48: (1, {'@': 1156}), 49: (1, {'@': 1156}), 6: (1, {'@': 1156}), 7: (1, {'@': 1156}), 9: (1, {'@': 1156}), 53: (1, {'@': 1156}), 58: (1, {'@': 1156}), 59: (1, {'@': 1156}), 22: (1, {'@': 1156}), 61: (1, {'@': 1156}), 126: (1, {'@': 1156}), 28: (1, {'@': 1156}), 31: (1, {'@': 1156}), 33: (1, {'@': 1156}), 34: (1, {'@': 1156}), 36: (1, {'@': 1156}), 69: (1, {'@': 1156}), 72: (1, {'@': 1156}), 75: (1, {'@': 1156})}, 1897: {57: (1, {'@': 1443}), 60: (1, {'@': 1443}), 6: (1, {'@': 1443}), 7: (1, {'@': 1443}), 61: (1, {'@': 1443}), 126: (1, {'@': 1443}), 45: (1, {'@': 1443}), 37: (1, {'@': 1443}), 38: (1, {'@': 1443}), 47: (1, {'@': 1443}), 26: (1, {'@': 1443}), 27: (1, {'@': 1443}), 4: (1, {'@': 1443}), 28: (1, {'@': 1443}), 50: (1, {'@': 1443}), 53: (1, {'@': 1443}), 67: (1, {'@': 1443}), 29: (1, {'@': 1443}), 30: (1, {'@': 1443}), 15: (1, {'@': 1443}), 43: (1, {'@': 1443}), 21: (1, {'@': 1443}), 44: (1, {'@': 1443}), 33: (1, {'@': 1443}), 64: (1, {'@': 1443}), 34: (1, {'@': 1443}), 54: (1, {'@': 1443}), 69: (1, {'@': 1443}), 40: (1, {'@': 1443}), 74: (1, {'@': 1443}), 41: (1, {'@': 1443}), 75: (1, {'@': 1443}), 18: (1, {'@': 1443}), 1: (1, {'@': 1443}), 2: (1, {'@': 1443}), 48: (1, {'@': 1443}), 49: (1, {'@': 1443}), 51: (1, {'@': 1443}), 52: (1, {'@': 1443}), 8: (1, {'@': 1443}), 9: (1, {'@': 1443}), 11: (1, {'@': 1443}), 55: (1, {'@': 1443}), 17: (1, {'@': 1443}), 58: (1, {'@': 1443}), 59: (1, {'@': 1443}), 22: (1, {'@': 1443}), 62: (1, {'@': 1443}), 23: (1, {'@': 1443}), 25: (1, {'@': 1443}), 63: (1, {'@': 1443}), 31: (1, {'@': 1443}), 66: (1, {'@': 1443}), 36: (1, {'@': 1443}), 68: (1, {'@': 1443}), 70: (1, {'@': 1443}), 71: (1, {'@': 1443}), 72: (1, {'@': 1443}), 73: (1, {'@': 1443})}, 1898: {57: (1, {'@': 873}), 60: (1, {'@': 873}), 61: (1, {'@': 873}), 53: (1, {'@': 873}), 67: (1, {'@': 873}), 126: (1, {'@': 873}), 37: (1, {'@': 873}), 45: (1, {'@': 873}), 38: (1, {'@': 873}), 26: (1, {'@': 873}), 27: (1, {'@': 873}), 4: (1, {'@': 873}), 29: (1, {'@': 873}), 30: (1, {'@': 873}), 15: (1, {'@': 873})}, 1899: {80: (0, 2434), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 399: (0, 2436), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 86: (0, 2438), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 1900: {441: (1, {'@': 1742}), 126: (1, {'@': 1742})}, 1901: {112: (0, 2374)}, 1902: {441: (1, {'@': 1741}), 126: (1, {'@': 1741})}, 1903: {57: (1, {'@': 875}), 60: (1, {'@': 875}), 61: (1, {'@': 875}), 53: (1, {'@': 875}), 67: (1, {'@': 875}), 126: (1, {'@': 875}), 37: (1, {'@': 875}), 45: (1, {'@': 875}), 38: (1, {'@': 875}), 26: (1, {'@': 875}), 27: (1, {'@': 875}), 4: (1, {'@': 875}), 29: (1, {'@': 875}), 30: (1, {'@': 875}), 15: (1, {'@': 875})}, 1904: {60: (1, {'@': 1016}), 21: (1, {'@': 1016}), 22: (1, {'@': 1016}), 44: (1, {'@': 1016}), 126: (1, {'@': 1016}), 62: (1, {'@': 1016}), 61: (1, {'@': 1016}), 28: (1, {'@': 1016}), 33: (1, {'@': 1016}), 6: (1, {'@': 1016}), 64: (1, {'@': 1016}), 34: (1, {'@': 1016}), 53: (1, {'@': 1016}), 54: (1, {'@': 1016}), 69: (1, {'@': 1016}), 40: (1, {'@': 1016}), 73: (1, {'@': 1016}), 75: (1, {'@': 1016}), 57: (1, {'@': 1016}), 18: (1, {'@': 1016})}, 1905: {126: (1, {'@': 1740}), 60: (1, {'@': 1740})}, 1906: {112: (0, 2381)}, 1907: {60: (1, {'@': 1008}), 21: (1, {'@': 1008}), 22: (1, {'@': 1008}), 44: (1, {'@': 1008}), 126: (1, {'@': 1008}), 62: (1, {'@': 1008}), 61: (1, {'@': 1008}), 28: (1, {'@': 1008}), 33: (1, {'@': 1008}), 6: (1, {'@': 1008}), 64: (1, {'@': 1008}), 34: (1, {'@': 1008}), 53: (1, {'@': 1008}), 54: (1, {'@': 1008}), 69: (1, {'@': 1008}), 40: (1, {'@': 1008}), 73: (1, {'@': 1008}), 75: (1, {'@': 1008}), 57: (1, {'@': 1008}), 18: (1, {'@': 1008})}, 1908: {126: (1, {'@': 1605}), 60: (1, {'@': 1605})}, 1909: {112: (0, 2590)}, 1910: {504: (0, 2277), 505: (0, 503), 503: (0, 2273), 506: (0, 505)}, 1911: {57: (1, {'@': 1147}), 60: (1, {'@': 1147}), 48: (1, {'@': 1147}), 49: (1, {'@': 1147}), 6: (1, {'@': 1147}), 7: (1, {'@': 1147}), 9: (1, {'@': 1147}), 53: (1, {'@': 1147}), 58: (1, {'@': 1147}), 59: (1, {'@': 1147}), 22: (1, {'@': 1147}), 61: (1, {'@': 1147}), 126: (1, {'@': 1147}), 28: (1, {'@': 1147}), 31: (1, {'@': 1147}), 33: (1, {'@': 1147}), 34: (1, {'@': 1147}), 36: (1, {'@': 1147}), 69: (1, {'@': 1147}), 72: (1, {'@': 1147}), 75: (1, {'@': 1147})}, 1912: {60: (1, {'@': 1023}), 21: (1, {'@': 1023}), 22: (1, {'@': 1023}), 44: (1, {'@': 1023}), 126: (1, {'@': 1023}), 62: (1, {'@': 1023}), 61: (1, {'@': 1023}), 28: (1, {'@': 1023}), 33: (1, {'@': 1023}), 6: (1, {'@': 1023}), 64: (1, {'@': 1023}), 34: (1, {'@': 1023}), 53: (1, {'@': 1023}), 54: (1, {'@': 1023}), 69: (1, {'@': 1023}), 40: (1, {'@': 1023}), 73: (1, {'@': 1023}), 75: (1, {'@': 1023}), 57: (1, {'@': 1023}), 18: (1, {'@': 1023})}, 1913: {112: (0, 2533)}, 1914: {126: (1, {'@': 1633}), 60: (1, {'@': 1633})}, 1915: {60: (1, {'@': 1135}), 57: (1, {'@': 1135})}, 1916: {60: (1, {'@': 1022}), 21: (1, {'@': 1022}), 22: (1, {'@': 1022}), 44: (1, {'@': 1022}), 126: (1, {'@': 1022}), 62: (1, {'@': 1022}), 61: (1, {'@': 1022}), 28: (1, {'@': 1022}), 33: (1, {'@': 1022}), 6: (1, {'@': 1022}), 64: (1, {'@': 1022}), 34: (1, {'@': 1022}), 53: (1, {'@': 1022}), 54: (1, {'@': 1022}), 69: (1, {'@': 1022}), 40: (1, {'@': 1022}), 73: (1, {'@': 1022}), 75: (1, {'@': 1022}), 57: (1, {'@': 1022}), 18: (1, {'@': 1022})}, 1917: {57: (1, {'@': 876}), 60: (1, {'@': 876}), 61: (1, {'@': 876}), 53: (1, {'@': 876}), 67: (1, {'@': 876}), 126: (1, {'@': 876}), 37: (1, {'@': 876}), 45: (1, {'@': 876}), 38: (1, {'@': 876}), 26: (1, {'@': 876}), 27: (1, {'@': 876}), 4: (1, {'@': 876}), 29: (1, {'@': 876}), 30: (1, {'@': 876}), 15: (1, {'@': 876})}, 1918: {57: (1, {'@': 1140}), 60: (1, {'@': 1140}), 48: (1, {'@': 1140}), 49: (1, {'@': 1140}), 6: (1, {'@': 1140}), 7: (1, {'@': 1140}), 9: (1, {'@': 1140}), 53: (1, {'@': 1140}), 58: (1, {'@': 1140}), 59: (1, {'@': 1140}), 22: (1, {'@': 1140}), 61: (1, {'@': 1140}), 126: (1, {'@': 1140}), 28: (1, {'@': 1140}), 31: (1, {'@': 1140}), 33: (1, {'@': 1140}), 34: (1, {'@': 1140}), 36: (1, {'@': 1140}), 69: (1, {'@': 1140}), 72: (1, {'@': 1140}), 75: (1, {'@': 1140})}, 1919: {60: (1, {'@': 1012}), 21: (1, {'@': 1012}), 22: (1, {'@': 1012}), 44: (1, {'@': 1012}), 126: (1, {'@': 1012}), 62: (1, {'@': 1012}), 61: (1, {'@': 1012}), 28: (1, {'@': 1012}), 33: (1, {'@': 1012}), 6: (1, {'@': 1012}), 64: (1, {'@': 1012}), 34: (1, {'@': 1012}), 53: (1, {'@': 1012}), 54: (1, {'@': 1012}), 69: (1, {'@': 1012}), 40: (1, {'@': 1012}), 73: (1, {'@': 1012}), 75: (1, {'@': 1012}), 57: (1, {'@': 1012}), 18: (1, {'@': 1012})}, 1920: {112: (0, 2566)}, 1921: {57: (1, {'@': 1150}), 60: (1, {'@': 1150}), 48: (1, {'@': 1150}), 49: (1, {'@': 1150}), 6: (1, {'@': 1150}), 7: (1, {'@': 1150}), 9: (1, {'@': 1150}), 53: (1, {'@': 1150}), 58: (1, {'@': 1150}), 59: (1, {'@': 1150}), 22: (1, {'@': 1150}), 61: (1, {'@': 1150}), 126: (1, {'@': 1150}), 28: (1, {'@': 1150}), 31: (1, {'@': 1150}), 33: (1, {'@': 1150}), 34: (1, {'@': 1150}), 36: (1, {'@': 1150}), 69: (1, {'@': 1150}), 72: (1, {'@': 1150}), 75: (1, {'@': 1150})}, 1922: {60: (1, {'@': 1024}), 21: (1, {'@': 1024}), 22: (1, {'@': 1024}), 44: (1, {'@': 1024}), 126: (1, {'@': 1024}), 62: (1, {'@': 1024}), 61: (1, {'@': 1024}), 28: (1, {'@': 1024}), 33: (1, {'@': 1024}), 6: (1, {'@': 1024}), 64: (1, {'@': 1024}), 34: (1, {'@': 1024}), 53: (1, {'@': 1024}), 54: (1, {'@': 1024}), 69: (1, {'@': 1024}), 40: (1, {'@': 1024}), 73: (1, {'@': 1024}), 75: (1, {'@': 1024}), 57: (1, {'@': 1024}), 18: (1, {'@': 1024})}, 1923: {60: (1, {'@': 497}), 57: (1, {'@': 497})}, 1924: {57: (1, {'@': 882}), 60: (1, {'@': 882}), 61: (1, {'@': 882}), 53: (1, {'@': 882}), 67: (1, {'@': 882}), 126: (1, {'@': 882}), 37: (1, {'@': 882}), 45: (1, {'@': 882}), 38: (1, {'@': 882}), 26: (1, {'@': 882}), 27: (1, {'@': 882}), 4: (1, {'@': 882}), 29: (1, {'@': 882}), 30: (1, {'@': 882}), 15: (1, {'@': 882})}, 1925: {57: (1, {'@': 511}), 60: (1, {'@': 511})}, 1926: {57: (1, {'@': 1142}), 60: (1, {'@': 1142}), 48: (1, {'@': 1142}), 49: (1, {'@': 1142}), 6: (1, {'@': 1142}), 7: (1, {'@': 1142}), 9: (1, {'@': 1142}), 53: (1, {'@': 1142}), 58: (1, {'@': 1142}), 59: (1, {'@': 1142}), 22: (1, {'@': 1142}), 61: (1, {'@': 1142}), 126: (1, {'@': 1142}), 28: (1, {'@': 1142}), 31: (1, {'@': 1142}), 33: (1, {'@': 1142}), 34: (1, {'@': 1142}), 36: (1, {'@': 1142}), 69: (1, {'@': 1142}), 72: (1, {'@': 1142}), 75: (1, {'@': 1142})}, 1927: {60: (1, {'@': 1004}), 57: (1, {'@': 1004})}, 1928: {60: (0, 2285)}, 1929: {57: (1, {'@': 874}), 60: (1, {'@': 874}), 61: (1, {'@': 874}), 53: (1, {'@': 874}), 67: (1, {'@': 874}), 126: (1, {'@': 874}), 37: (1, {'@': 874}), 45: (1, {'@': 874}), 38: (1, {'@': 874}), 26: (1, {'@': 874}), 27: (1, {'@': 874}), 4: (1, {'@': 874}), 29: (1, {'@': 874}), 30: (1, {'@': 874}), 15: (1, {'@': 874})}, 1930: {60: (0, 2270)}, 1931: {57: (1, {'@': 1155}), 60: (1, {'@': 1155}), 48: (1, {'@': 1155}), 49: (1, {'@': 1155}), 6: (1, {'@': 1155}), 7: (1, {'@': 1155}), 9: (1, {'@': 1155}), 53: (1, {'@': 1155}), 58: (1, {'@': 1155}), 59: (1, {'@': 1155}), 22: (1, {'@': 1155}), 61: (1, {'@': 1155}), 126: (1, {'@': 1155}), 28: (1, {'@': 1155}), 31: (1, {'@': 1155}), 33: (1, {'@': 1155}), 34: (1, {'@': 1155}), 36: (1, {'@': 1155}), 69: (1, {'@': 1155}), 72: (1, {'@': 1155}), 75: (1, {'@': 1155})}, 1932: {60: (1, {'@': 1009}), 21: (1, {'@': 1009}), 22: (1, {'@': 1009}), 44: (1, {'@': 1009}), 126: (1, {'@': 1009}), 62: (1, {'@': 1009}), 61: (1, {'@': 1009}), 28: (1, {'@': 1009}), 33: (1, {'@': 1009}), 6: (1, {'@': 1009}), 64: (1, {'@': 1009}), 34: (1, {'@': 1009}), 53: (1, {'@': 1009}), 54: (1, {'@': 1009}), 69: (1, {'@': 1009}), 40: (1, {'@': 1009}), 73: (1, {'@': 1009}), 75: (1, {'@': 1009}), 57: (1, {'@': 1009}), 18: (1, {'@': 1009})}, 1933: {57: (1, {'@': 878}), 60: (1, {'@': 878}), 61: (1, {'@': 878}), 53: (1, {'@': 878}), 67: (1, {'@': 878}), 126: (1, {'@': 878}), 37: (1, {'@': 878}), 45: (1, {'@': 878}), 38: (1, {'@': 878}), 26: (1, {'@': 878}), 27: (1, {'@': 878}), 4: (1, {'@': 878}), 29: (1, {'@': 878}), 30: (1, {'@': 878}), 15: (1, {'@': 878})}, 1934: {57: (1, {'@': 505}), 60: (1, {'@': 505}), 126: (1, {'@': 505}), 539: (1, {'@': 505})}, 1935: {177: (1, {'@': 591}), 7: (1, {'@': 591}), 22: (1, {'@': 591}), 60: (1, {'@': 591}), 126: (1, {'@': 591}), 48: (1, {'@': 591}), 72: (1, {'@': 591}), 178: (1, {'@': 591}), 179: (1, {'@': 591}), 49: (1, {'@': 591}), 57: (1, {'@': 591})}, 1936: {60: (1, {'@': 1017}), 21: (1, {'@': 1017}), 22: (1, {'@': 1017}), 44: (1, {'@': 1017}), 126: (1, {'@': 1017}), 62: (1, {'@': 1017}), 61: (1, {'@': 1017}), 28: (1, {'@': 1017}), 33: (1, {'@': 1017}), 6: (1, {'@': 1017}), 64: (1, {'@': 1017}), 34: (1, {'@': 1017}), 53: (1, {'@': 1017}), 54: (1, {'@': 1017}), 69: (1, {'@': 1017}), 40: (1, {'@': 1017}), 73: (1, {'@': 1017}), 75: (1, {'@': 1017}), 57: (1, {'@': 1017}), 18: (1, {'@': 1017})}, 1937: {60: (0, 2290)}, 1938: {60: (0, 2293)}, 1939: {146: (1, {'@': 383}), 126: (1, {'@': 1365}), 53: (1, {'@': 1365}), 57: (1, {'@': 1365}), 60: (1, {'@': 1365})}, 1940: {177: (1, {'@': 592}), 7: (1, {'@': 592}), 22: (1, {'@': 592}), 60: (1, {'@': 592}), 126: (1, {'@': 592}), 48: (1, {'@': 592}), 72: (1, {'@': 592}), 178: (1, {'@': 592}), 179: (1, {'@': 592}), 49: (1, {'@': 592}), 57: (1, {'@': 592})}, 1941: {60: (1, {'@': 1021}), 21: (1, {'@': 1021}), 22: (1, {'@': 1021}), 44: (1, {'@': 1021}), 126: (1, {'@': 1021}), 62: (1, {'@': 1021}), 61: (1, {'@': 1021}), 28: (1, {'@': 1021}), 33: (1, {'@': 1021}), 6: (1, {'@': 1021}), 64: (1, {'@': 1021}), 34: (1, {'@': 1021}), 53: (1, {'@': 1021}), 54: (1, {'@': 1021}), 69: (1, {'@': 1021}), 40: (1, {'@': 1021}), 73: (1, {'@': 1021}), 75: (1, {'@': 1021}), 57: (1, {'@': 1021}), 18: (1, {'@': 1021})}, 1942: {57: (1, {'@': 509}), 60: (1, {'@': 509})}, 1943: {146: (0, 2297)}, 1944: {126: (1, {'@': 414}), 146: (1, {'@': 414}), 60: (1, {'@': 414})}, 1945: {177: (1, {'@': 595}), 7: (1, {'@': 595}), 22: (1, {'@': 595}), 60: (1, {'@': 595}), 126: (1, {'@': 595}), 48: (1, {'@': 595}), 72: (1, {'@': 595}), 178: (1, {'@': 595}), 179: (1, {'@': 595}), 49: (1, {'@': 595}), 57: (1, {'@': 595})}, 1946: {60: (1, {'@': 1011}), 21: (1, {'@': 1011}), 22: (1, {'@': 1011}), 44: (1, {'@': 1011}), 126: (1, {'@': 1011}), 62: (1, {'@': 1011}), 61: (1, {'@': 1011}), 28: (1, {'@': 1011}), 33: (1, {'@': 1011}), 6: (1, {'@': 1011}), 64: (1, {'@': 1011}), 34: (1, {'@': 1011}), 53: (1, {'@': 1011}), 54: (1, {'@': 1011}), 69: (1, {'@': 1011}), 40: (1, {'@': 1011}), 73: (1, {'@': 1011}), 75: (1, {'@': 1011}), 57: (1, {'@': 1011}), 18: (1, {'@': 1011})}, 1947: {60: (0, 2206)}, 1948: {146: (0, 2303)}, 1949: {126: (1, {'@': 370}), 146: (1, {'@': 370}), 60: (1, {'@': 370})}, 1950: {112: (0, 2431)}, 1951: {60: (1, {'@': 1013}), 21: (1, {'@': 1013}), 22: (1, {'@': 1013}), 44: (1, {'@': 1013}), 126: (1, {'@': 1013}), 62: (1, {'@': 1013}), 61: (1, {'@': 1013}), 28: (1, {'@': 1013}), 33: (1, {'@': 1013}), 6: (1, {'@': 1013}), 64: (1, {'@': 1013}), 34: (1, {'@': 1013}), 53: (1, {'@': 1013}), 54: (1, {'@': 1013}), 69: (1, {'@': 1013}), 40: (1, {'@': 1013}), 73: (1, {'@': 1013}), 75: (1, {'@': 1013}), 57: (1, {'@': 1013}), 18: (1, {'@': 1013})}, 1952: {60: (0, 1034)}, 1953: {57: (1, {'@': 502}), 60: (1, {'@': 502})}, 1954: {126: (1, {'@': 388}), 146: (1, {'@': 388}), 60: (1, {'@': 388})}, 1955: {177: (1, {'@': 598}), 7: (1, {'@': 598}), 22: (1, {'@': 598}), 60: (1, {'@': 598}), 126: (1, {'@': 598}), 48: (1, {'@': 598}), 72: (1, {'@': 598}), 178: (1, {'@': 598}), 179: (1, {'@': 598}), 49: (1, {'@': 598}), 57: (1, {'@': 598})}, 1956: {57: (1, {'@': 500}), 60: (1, {'@': 500})}, 1957: {146: (1, {'@': 393}), 126: (1, {'@': 1368}), 53: (1, {'@': 1368}), 57: (1, {'@': 1368}), 60: (1, {'@': 1368})}, 1958: {60: (1, {'@': 587}), 57: (1, {'@': 587})}, 1959: {212: (0, 1759), 59: (0, 363), 60: (1, {'@': 528}), 57: (1, {'@': 528})}, 1960: {126: (1, {'@': 412}), 146: (1, {'@': 412}), 60: (1, {'@': 412})}, 1961: {177: (1, {'@': 596}), 7: (1, {'@': 596}), 22: (1, {'@': 596}), 60: (1, {'@': 596}), 126: (1, {'@': 596}), 48: (1, {'@': 596}), 72: (1, {'@': 596}), 178: (1, {'@': 596}), 179: (1, {'@': 596}), 49: (1, {'@': 596}), 57: (1, {'@': 596})}, 1962: {193: (0, 53), 192: (0, 305), 126: (0, 380), 57: (1, {'@': 779}), 60: (1, {'@': 779})}, 1963: {144: (0, 2316), 145: (0, 355)}, 1964: {126: (0, 2324), 667: (0, 2330), 60: (0, 2332)}, 1965: {146: (1, {'@': 389}), 126: (1, {'@': 1366}), 53: (1, {'@': 1366}), 57: (1, {'@': 1366}), 60: (1, {'@': 1366})}, 1966: {177: (1, {'@': 594}), 7: (1, {'@': 594}), 22: (1, {'@': 594}), 60: (1, {'@': 594}), 126: (1, {'@': 594}), 48: (1, {'@': 594}), 72: (1, {'@': 594}), 178: (1, {'@': 594}), 179: (1, {'@': 594}), 49: (1, {'@': 594}), 57: (1, {'@': 594})}, 1967: {146: (0, 2309)}, 1968: {146: (0, 2598)}, 1969: {22: (0, 389), 53: (0, 387), 7: (0, 45), 198: (0, 1827), 402: (0, 120), 59: (0, 363), 206: (0, 1456), 49: (0, 335), 34: (0, 1589), 212: (0, 1466), 180: (0, 1460), 287: (0, 1471), 200: (0, 1474), 69: (0, 1760), 126: (0, 183), 172: (0, 1481), 60: (1, {'@': 1127}), 57: (1, {'@': 1127})}, 1970: {400: (0, 1799), 401: (0, 308), 126: (0, 360)}, 1971: {60: (0, 1934)}, 1972: {2: (1, {'@': 818}), 60: (1, {'@': 818}), 44: (1, {'@': 818}), 61: (1, {'@': 818}), 126: (1, {'@': 818}), 63: (1, {'@': 818}), 28: (1, {'@': 818}), 33: (1, {'@': 818}), 6: (1, {'@': 818}), 52: (1, {'@': 818}), 8: (1, {'@': 818}), 53: (1, {'@': 818}), 37: (1, {'@': 818}), 71: (1, {'@': 818}), 55: (1, {'@': 818}), 57: (1, {'@': 818})}, 1973: {126: (1, {'@': 365}), 146: (1, {'@': 365}), 60: (1, {'@': 365})}, 1974: {146: (0, 267)}, 1975: {146: (0, 2315)}, 1976: {668: (0, 609), 669: (0, 2104), 670: (0, 2107)}, 1977: {60: (0, 364)}, 1978: {33: (1, {'@': 860}), 58: (1, {'@': 860}), 6: (1, {'@': 860}), 60: (1, {'@': 860}), 44: (1, {'@': 860}), 66: (1, {'@': 860}), 53: (1, {'@': 860}), 126: (1, {'@': 860}), 37: (1, {'@': 860}), 28: (1, {'@': 860}), 57: (1, {'@': 860}), 43: (1, {'@': 860}), 1: (1, {'@': 860}), 2: (1, {'@': 860}), 45: (1, {'@': 860}), 47: (1, {'@': 860}), 48: (1, {'@': 860}), 4: (1, {'@': 860}), 49: (1, {'@': 860}), 50: (1, {'@': 860}), 51: (1, {'@': 860}), 52: (1, {'@': 860}), 8: (1, {'@': 860}), 7: (1, {'@': 860}), 9: (1, {'@': 860}), 11: (1, {'@': 860}), 54: (1, {'@': 860}), 55: (1, {'@': 860}), 15: (1, {'@': 860}), 17: (1, {'@': 860}), 18: (1, {'@': 860}), 59: (1, {'@': 860}), 21: (1, {'@': 860}), 22: (1, {'@': 860}), 61: (1, {'@': 860}), 62: (1, {'@': 860}), 23: (1, {'@': 860}), 25: (1, {'@': 860}), 26: (1, {'@': 860}), 63: (1, {'@': 860}), 27: (1, {'@': 860}), 29: (1, {'@': 860}), 30: (1, {'@': 860}), 31: (1, {'@': 860}), 64: (1, {'@': 860}), 67: (1, {'@': 860}), 34: (1, {'@': 860}), 36: (1, {'@': 860}), 68: (1, {'@': 860}), 38: (1, {'@': 860}), 69: (1, {'@': 860}), 70: (1, {'@': 860}), 71: (1, {'@': 860}), 40: (1, {'@': 860}), 72: (1, {'@': 860}), 41: (1, {'@': 860}), 73: (1, {'@': 860}), 74: (1, {'@': 860}), 75: (1, {'@': 860})}, 1979: {60: (0, 159)}, 1980: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 628)}, 1981: {112: (0, 1052)}, 1982: {60: (1, {'@': 1506})}, 1983: {60: (0, 285)}, 1984: {112: (1, {'@': 1715}), 441: (1, {'@': 1715}), 89: (1, {'@': 1715}), 442: (1, {'@': 1715}), 107: (1, {'@': 1715}), 443: (1, {'@': 1715}), 60: (1, {'@': 1715})}, 1985: {112: (0, 778)}, 1986: {441: (0, 175)}, 1987: {126: (1, {'@': 769}), 193: (1, {'@': 769}), 57: (1, {'@': 769}), 60: (1, {'@': 769})}, 1988: {112: (1, {'@': 1705}), 89: (1, {'@': 1705}), 97: (1, {'@': 1705}), 107: (1, {'@': 1705}), 126: (1, {'@': 1705}), 146: (1, {'@': 1705}), 60: (1, {'@': 1705})}, 1989: {107: (0, 2409), 112: (0, 2376), 81: (0, 2295), 80: (0, 2414), 194: (0, 1223), 97: (0, 2370), 89: (0, 2384), 428: (0, 587)}, 1990: {112: (0, 2001), 450: (0, 1991), 89: (0, 1990), 451: (0, 276), 107: (0, 2029), 442: (0, 1984), 443: (0, 268)}, 1991: {107: (0, 279), 89: (0, 293), 442: (0, 261), 112: (0, 310), 441: (1, {'@': 1540}), 443: (1, {'@': 1540}), 60: (1, {'@': 1540})}, 1992: {515: (1, {'@': 569}), 517: (1, {'@': 569}), 60: (1, {'@': 569}), 126: (1, {'@': 569}), 514: (1, {'@': 569}), 57: (1, {'@': 569})}, 1993: {112: (0, 2041)}, 1994: {112: (1, {'@': 1703}), 89: (1, {'@': 1703}), 97: (1, {'@': 1703}), 107: (1, {'@': 1703}), 126: (1, {'@': 1703}), 146: (1, {'@': 1703}), 60: (1, {'@': 1703})}, 1995: {57: (1, {'@': 785}), 60: (1, {'@': 785}), 126: (1, {'@': 785}), 193: (1, {'@': 785})}, 1996: {60: (1, {'@': 1505})}, 1997: {107: (0, 2409), 112: (0, 2376), 81: (0, 2295), 80: (0, 2414), 194: (0, 1223), 97: (0, 2370), 428: (0, 1161), 89: (0, 2384)}, 1998: {60: (0, 290)}, 1999: {515: (1, {'@': 568}), 517: (1, {'@': 568}), 60: (1, {'@': 568}), 126: (1, {'@': 568}), 514: (1, {'@': 568}), 57: (1, {'@': 568})}, 2000: {57: (1, {'@': 1200}), 60: (1, {'@': 1200}), 43: (1, {'@': 1200}), 1: (1, {'@': 1200}), 2: (1, {'@': 1200}), 44: (1, {'@': 1200}), 45: (1, {'@': 1200}), 47: (1, {'@': 1200}), 48: (1, {'@': 1200}), 4: (1, {'@': 1200}), 49: (1, {'@': 1200}), 50: (1, {'@': 1200}), 51: (1, {'@': 1200}), 6: (1, {'@': 1200}), 52: (1, {'@': 1200}), 8: (1, {'@': 1200}), 7: (1, {'@': 1200}), 9: (1, {'@': 1200}), 53: (1, {'@': 1200}), 11: (1, {'@': 1200}), 54: (1, {'@': 1200}), 55: (1, {'@': 1200}), 15: (1, {'@': 1200}), 17: (1, {'@': 1200}), 18: (1, {'@': 1200}), 58: (1, {'@': 1200}), 59: (1, {'@': 1200}), 21: (1, {'@': 1200}), 22: (1, {'@': 1200}), 61: (1, {'@': 1200}), 126: (1, {'@': 1200}), 62: (1, {'@': 1200}), 23: (1, {'@': 1200}), 25: (1, {'@': 1200}), 26: (1, {'@': 1200}), 63: (1, {'@': 1200}), 27: (1, {'@': 1200}), 28: (1, {'@': 1200}), 29: (1, {'@': 1200}), 30: (1, {'@': 1200}), 31: (1, {'@': 1200}), 33: (1, {'@': 1200}), 64: (1, {'@': 1200}), 66: (1, {'@': 1200}), 67: (1, {'@': 1200}), 34: (1, {'@': 1200}), 36: (1, {'@': 1200}), 37: (1, {'@': 1200}), 68: (1, {'@': 1200}), 38: (1, {'@': 1200}), 69: (1, {'@': 1200}), 70: (1, {'@': 1200}), 71: (1, {'@': 1200}), 40: (1, {'@': 1200}), 72: (1, {'@': 1200}), 41: (1, {'@': 1200}), 73: (1, {'@': 1200}), 74: (1, {'@': 1200}), 75: (1, {'@': 1200})}, 2001: {112: (0, 2001), 450: (0, 1991), 89: (0, 1990), 451: (0, 278), 107: (0, 2029), 442: (0, 1984), 60: (0, 291)}, 2002: {671: (0, 615), 537: (0, 599), 536: (0, 670), 522: (0, 623), 523: (0, 719)}, 2003: {146: (0, 336)}, 2004: {60: (0, 370)}, 2005: {146: (0, 1029), 60: (0, 1064)}, 2006: {146: (0, 753)}, 2007: {146: (0, 353)}, 2008: {60: (0, 1050)}, 2009: {60: (1, {'@': 1331}), 57: (1, {'@': 1331})}, 2010: {112: (0, 749)}, 2011: {60: (0, 2002)}, 2012: {512: (0, 1115), 672: (0, 1118), 513: (0, 1992), 514: (0, 1981), 126: (0, 1124), 515: (0, 1993), 516: (0, 1999), 517: (0, 2030), 519: (0, 2021), 57: (1, {'@': 566}), 60: (1, {'@': 566})}, 2013: {112: (0, 2001), 450: (0, 1991), 89: (0, 1990), 451: (0, 270), 107: (0, 2029), 442: (0, 1984), 441: (0, 302)}, 2014: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 1151)}, 2015: {146: (0, 319)}, 2016: {112: (0, 1081)}, 2017: {60: (1, {'@': 537}), 57: (1, {'@': 537})}, 2018: {57: (1, {'@': 1354}), 60: (1, {'@': 1354}), 470: (1, {'@': 1354}), 126: (1, {'@': 1354})}, 2019: {60: (1, {'@': 564}), 57: (1, {'@': 564})}, 2020: {146: (0, 2191)}, 2021: {515: (1, {'@': 567}), 517: (1, {'@': 567}), 60: (1, {'@': 567}), 126: (1, {'@': 567}), 514: (1, {'@': 567}), 57: (1, {'@': 567})}, 2022: {60: (1, {'@': 1330}), 57: (1, {'@': 1330})}, 2023: {144: (0, 2316), 145: (0, 1103)}, 2024: {144: (0, 2316), 145: (0, 1166)}, 2025: {112: (0, 2001), 450: (0, 1991), 89: (0, 1990), 443: (0, 265), 451: (0, 282), 107: (0, 2029), 442: (0, 1984)}, 2026: {146: (0, 328)}, 2027: {268: (1, {'@': 1642}), 60: (1, {'@': 1642}), 126: (1, {'@': 1642}), 67: (1, {'@': 1642}), 270: (1, {'@': 1642}), 4: (1, {'@': 1642}), 266: (1, {'@': 1642}), 30: (1, {'@': 1642}), 57: (1, {'@': 1642})}, 2028: {6: (1, {'@': 1669}), 60: (1, {'@': 1669}), 7: (1, {'@': 1669}), 61: (1, {'@': 1669}), 126: (1, {'@': 1669}), 37: (1, {'@': 1669}), 27: (1, {'@': 1669}), 28: (1, {'@': 1669}), 57: (1, {'@': 1669})}, 2029: {112: (0, 2001), 450: (0, 1991), 89: (0, 1990), 441: (0, 346), 451: (0, 314), 107: (0, 2029), 442: (0, 1984)}, 2030: {112: (0, 1135)}, 2031: {405: (0, 477), 404: (0, 725), 403: (0, 2203), 314: (0, 2451)}, 2032: {146: (0, 2034)}, 2033: {57: (1, {'@': 507}), 60: (1, {'@': 507}), 126: (1, {'@': 507}), 524: (1, {'@': 507})}, 2034: {424: (0, 513), 425: (0, 516), 423: (0, 2008), 422: (0, 337)}, 2035: {60: (0, 1237)}, 2036: {60: (0, 272)}, 2037: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 1077)}, 2038: {265: (0, 993), 4: (0, 405), 266: (0, 1016), 268: (0, 1462), 267: (0, 307), 269: (0, 1465), 67: (0, 1913), 166: (0, 1468), 270: (0, 1470), 30: (0, 1920), 162: (0, 1472), 161: (0, 1476), 272: (0, 1483)}, 2039: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 194: (0, 1148), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 2040: {268: (1, {'@': 1639}), 60: (1, {'@': 1639}), 126: (1, {'@': 1639}), 67: (1, {'@': 1639}), 270: (1, {'@': 1639}), 4: (1, {'@': 1639}), 266: (1, {'@': 1639}), 30: (1, {'@': 1639}), 57: (1, {'@': 1639})}, 2041: {664: (0, 281), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 661: (0, 776), 662: (0, 779), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 86: (0, 1459), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 663: (0, 1463), 673: (0, 1469), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2042: {126: (0, 289), 146: (1, {'@': 1059})}, 2043: {112: (1, {'@': 1708}), 89: (1, {'@': 1708}), 97: (1, {'@': 1708}), 107: (1, {'@': 1708}), 126: (1, {'@': 1708}), 146: (1, {'@': 1708}), 60: (1, {'@': 1708})}, 2044: {57: (1, {'@': 1199}), 60: (1, {'@': 1199}), 43: (1, {'@': 1199}), 1: (1, {'@': 1199}), 2: (1, {'@': 1199}), 44: (1, {'@': 1199}), 45: (1, {'@': 1199}), 47: (1, {'@': 1199}), 48: (1, {'@': 1199}), 4: (1, {'@': 1199}), 49: (1, {'@': 1199}), 50: (1, {'@': 1199}), 51: (1, {'@': 1199}), 6: (1, {'@': 1199}), 52: (1, {'@': 1199}), 8: (1, {'@': 1199}), 7: (1, {'@': 1199}), 9: (1, {'@': 1199}), 53: (1, {'@': 1199}), 11: (1, {'@': 1199}), 54: (1, {'@': 1199}), 55: (1, {'@': 1199}), 15: (1, {'@': 1199}), 17: (1, {'@': 1199}), 18: (1, {'@': 1199}), 58: (1, {'@': 1199}), 59: (1, {'@': 1199}), 21: (1, {'@': 1199}), 22: (1, {'@': 1199}), 61: (1, {'@': 1199}), 126: (1, {'@': 1199}), 62: (1, {'@': 1199}), 23: (1, {'@': 1199}), 25: (1, {'@': 1199}), 26: (1, {'@': 1199}), 63: (1, {'@': 1199}), 27: (1, {'@': 1199}), 28: (1, {'@': 1199}), 29: (1, {'@': 1199}), 30: (1, {'@': 1199}), 31: (1, {'@': 1199}), 33: (1, {'@': 1199}), 64: (1, {'@': 1199}), 66: (1, {'@': 1199}), 67: (1, {'@': 1199}), 34: (1, {'@': 1199}), 36: (1, {'@': 1199}), 37: (1, {'@': 1199}), 68: (1, {'@': 1199}), 38: (1, {'@': 1199}), 69: (1, {'@': 1199}), 70: (1, {'@': 1199}), 71: (1, {'@': 1199}), 40: (1, {'@': 1199}), 72: (1, {'@': 1199}), 41: (1, {'@': 1199}), 73: (1, {'@': 1199}), 74: (1, {'@': 1199}), 75: (1, {'@': 1199})}, 2045: {126: (0, 736), 674: (0, 1044), 60: (1, {'@': 1549}), 146: (1, {'@': 1549})}, 2046: {146: (0, 275)}, 2047: {146: (0, 339)}, 2048: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 1061), 112: (0, 2376), 97: (0, 2370)}, 2049: {112: (0, 2001), 450: (0, 1991), 89: (0, 1990), 60: (0, 214), 107: (0, 2029), 442: (0, 1984), 451: (0, 263)}, 2050: {60: (0, 1110)}, 2051: {60: (0, 247)}, 2052: {60: (1, {'@': 1689}), 147: (1, {'@': 1689}), 154: (1, {'@': 1689}), 148: (1, {'@': 1689}), 126: (1, {'@': 1689}), 149: (1, {'@': 1689}), 155: (1, {'@': 1689}), 151: (1, {'@': 1689}), 152: (1, {'@': 1689}), 150: (1, {'@': 1689}), 156: (1, {'@': 1689}), 157: (1, {'@': 1689}), 158: (1, {'@': 1689}), 159: (1, {'@': 1689}), 153: (1, {'@': 1689}), 57: (1, {'@': 1689}), 160: (1, {'@': 1689})}, 2053: {60: (0, 348)}, 2054: {60: (1, {'@': 1293}), 147: (1, {'@': 1293}), 126: (1, {'@': 1293}), 148: (1, {'@': 1293}), 149: (1, {'@': 1293}), 150: (1, {'@': 1293}), 151: (1, {'@': 1293}), 152: (1, {'@': 1293}), 153: (1, {'@': 1293}), 154: (1, {'@': 1293}), 155: (1, {'@': 1293}), 156: (1, {'@': 1293}), 157: (1, {'@': 1293}), 158: (1, {'@': 1293}), 159: (1, {'@': 1293}), 57: (1, {'@': 1293}), 160: (1, {'@': 1293})}, 2055: {376: (0, 528), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 255: (0, 1221), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 379: (0, 540), 117: (0, 804), 86: (0, 543), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 42: (0, 858), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 380: (0, 1402), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 381: (0, 547), 90: (0, 853), 3: (0, 855), 123: (0, 856), 256: (0, 550), 39: (0, 860), 377: (0, 1101), 91: (0, 863), 124: (0, 864)}, 2056: {60: (0, 251)}, 2057: {126: (0, 741), 146: (1, {'@': 1201})}, 2058: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 1074)}, 2059: {60: (1, {'@': 1278}), 147: (1, {'@': 1278}), 126: (1, {'@': 1278}), 148: (1, {'@': 1278}), 149: (1, {'@': 1278}), 150: (1, {'@': 1278}), 151: (1, {'@': 1278}), 152: (1, {'@': 1278}), 153: (1, {'@': 1278}), 154: (1, {'@': 1278}), 155: (1, {'@': 1278}), 156: (1, {'@': 1278}), 157: (1, {'@': 1278}), 158: (1, {'@': 1278}), 159: (1, {'@': 1278}), 57: (1, {'@': 1278}), 160: (1, {'@': 1278})}, 2060: {296: (0, 2462), 58: (0, 1666), 48: (0, 1843), 29: (0, 1870), 63: (0, 2218), 64: (0, 1537), 53: (0, 387), 41: (0, 372), 70: (0, 1727), 50: (0, 1792), 26: (0, 1797), 484: (0, 2472), 8: (0, 1510), 38: (0, 1811), 183: (0, 2473), 49: (0, 335), 295: (0, 2475), 43: (0, 1548), 61: (0, 25), 165: (0, 2477), 1: (0, 1793), 69: (0, 1760), 67: (0, 1913), 45: (0, 1833), 30: (0, 1920), 51: (0, 1695), 71: (0, 2263), 206: (0, 2479), 52: (0, 1498), 6: (0, 20), 44: (0, 358), 203: (0, 2481), 280: (0, 2482), 40: (0, 1756), 15: (0, 1909), 33: (0, 383), 213: (0, 2484), 18: (0, 1581), 7: (0, 45), 445: (0, 2485), 66: (0, 1679), 21: (0, 366), 2: (0, 2225), 55: (0, 2229), 217: (0, 2487), 166: (0, 2489), 59: (0, 363), 182: (0, 2490), 212: (0, 2492), 34: (0, 1589), 284: (0, 2496), 28: (0, 33), 36: (0, 15), 54: (0, 1598), 164: (0, 2498), 72: (0, 1882), 286: (0, 2500), 31: (0, 1901), 17: (0, 50), 37: (0, 1828), 211: (0, 2501), 73: (0, 1763), 23: (0, 327), 22: (0, 389), 68: (0, 1724), 198: (0, 2505), 210: (0, 2507), 74: (0, 1616), 483: (0, 2508), 309: (0, 2510), 27: (0, 408), 392: (0, 2511), 180: (0, 2513), 292: (0, 2515), 398: (0, 2517), 287: (0, 2518), 4: (0, 405), 200: (0, 2519), 11: (0, 84), 162: (0, 2522), 47: (0, 1820), 172: (0, 2524), 197: (0, 2526), 410: (0, 2528), 202: (0, 2530), 9: (0, 1906), 290: (0, 2532), 204: (0, 2534), 205: (0, 2537), 167: (0, 2539), 485: (0, 376), 215: (0, 2541), 163: (0, 2543), 207: (0, 2545), 62: (0, 367), 185: (0, 2546), 170: (0, 2550), 75: (0, 341), 168: (0, 2551), 395: (0, 2553), 396: (0, 2554), 444: (0, 2556), 161: (0, 2558), 208: (0, 2560), 481: (0, 2561), 173: (0, 2564), 283: (0, 2567), 169: (0, 2568), 25: (0, 1783), 479: (0, 2571), 482: (0, 2572), 201: (0, 2575), 281: (0, 2577)}, 2061: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 194: (0, 1086), 112: (0, 2376), 97: (0, 2370)}, 2062: {60: (1, {'@': 1284}), 147: (1, {'@': 1284}), 126: (1, {'@': 1284}), 148: (1, {'@': 1284}), 149: (1, {'@': 1284}), 150: (1, {'@': 1284}), 151: (1, {'@': 1284}), 152: (1, {'@': 1284}), 153: (1, {'@': 1284}), 154: (1, {'@': 1284}), 155: (1, {'@': 1284}), 156: (1, {'@': 1284}), 157: (1, {'@': 1284}), 158: (1, {'@': 1284}), 159: (1, {'@': 1284}), 57: (1, {'@': 1284}), 160: (1, {'@': 1284})}, 2063: {43: (1, {'@': 1614}), 1: (1, {'@': 1614}), 2: (1, {'@': 1614}), 44: (1, {'@': 1614}), 45: (1, {'@': 1614}), 47: (1, {'@': 1614}), 48: (1, {'@': 1614}), 4: (1, {'@': 1614}), 49: (1, {'@': 1614}), 50: (1, {'@': 1614}), 51: (1, {'@': 1614}), 6: (1, {'@': 1614}), 52: (1, {'@': 1614}), 8: (1, {'@': 1614}), 7: (1, {'@': 1614}), 9: (1, {'@': 1614}), 53: (1, {'@': 1614}), 11: (1, {'@': 1614}), 54: (1, {'@': 1614}), 55: (1, {'@': 1614}), 15: (1, {'@': 1614}), 17: (1, {'@': 1614}), 57: (1, {'@': 1614}), 18: (1, {'@': 1614}), 58: (1, {'@': 1614}), 59: (1, {'@': 1614}), 21: (1, {'@': 1614}), 22: (1, {'@': 1614}), 60: (1, {'@': 1614}), 61: (1, {'@': 1614}), 126: (1, {'@': 1614}), 62: (1, {'@': 1614}), 23: (1, {'@': 1614}), 25: (1, {'@': 1614}), 26: (1, {'@': 1614}), 63: (1, {'@': 1614}), 27: (1, {'@': 1614}), 28: (1, {'@': 1614}), 29: (1, {'@': 1614}), 30: (1, {'@': 1614}), 31: (1, {'@': 1614}), 33: (1, {'@': 1614}), 64: (1, {'@': 1614}), 66: (1, {'@': 1614}), 67: (1, {'@': 1614}), 34: (1, {'@': 1614}), 36: (1, {'@': 1614}), 37: (1, {'@': 1614}), 68: (1, {'@': 1614}), 38: (1, {'@': 1614}), 69: (1, {'@': 1614}), 70: (1, {'@': 1614}), 71: (1, {'@': 1614}), 40: (1, {'@': 1614}), 72: (1, {'@': 1614}), 41: (1, {'@': 1614}), 73: (1, {'@': 1614}), 74: (1, {'@': 1614}), 75: (1, {'@': 1614})}, 2064: {296: (0, 2462), 58: (0, 1666), 48: (0, 1843), 29: (0, 1870), 63: (0, 2218), 64: (0, 1537), 53: (0, 387), 41: (0, 372), 70: (0, 1727), 50: (0, 1792), 26: (0, 1797), 484: (0, 2472), 8: (0, 1510), 38: (0, 1811), 183: (0, 2473), 49: (0, 335), 295: (0, 2475), 43: (0, 1548), 61: (0, 25), 165: (0, 2477), 1: (0, 1793), 69: (0, 1760), 67: (0, 1913), 45: (0, 1833), 30: (0, 1920), 51: (0, 1695), 126: (0, 381), 485: (0, 388), 71: (0, 2263), 206: (0, 2479), 52: (0, 1498), 6: (0, 20), 44: (0, 358), 203: (0, 2481), 280: (0, 2482), 40: (0, 1756), 15: (0, 1909), 33: (0, 383), 213: (0, 2484), 18: (0, 1581), 7: (0, 45), 445: (0, 2485), 66: (0, 1679), 21: (0, 366), 2: (0, 2225), 55: (0, 2229), 217: (0, 2487), 166: (0, 2489), 59: (0, 363), 182: (0, 2490), 212: (0, 2492), 34: (0, 1589), 284: (0, 2496), 28: (0, 33), 36: (0, 15), 54: (0, 1598), 164: (0, 2498), 72: (0, 1882), 286: (0, 2500), 31: (0, 1901), 17: (0, 50), 37: (0, 1828), 211: (0, 2501), 73: (0, 1763), 23: (0, 327), 22: (0, 389), 68: (0, 1724), 198: (0, 2505), 210: (0, 2507), 74: (0, 1616), 483: (0, 2508), 309: (0, 2510), 27: (0, 408), 392: (0, 2511), 180: (0, 2513), 292: (0, 2515), 398: (0, 2517), 287: (0, 2518), 4: (0, 405), 200: (0, 2519), 11: (0, 84), 162: (0, 2522), 47: (0, 1820), 172: (0, 2524), 197: (0, 2526), 410: (0, 2528), 202: (0, 2530), 9: (0, 1906), 290: (0, 2532), 204: (0, 2534), 205: (0, 2537), 167: (0, 2539), 215: (0, 2541), 163: (0, 2543), 207: (0, 2545), 62: (0, 367), 185: (0, 2546), 170: (0, 2550), 75: (0, 341), 168: (0, 2551), 395: (0, 2553), 396: (0, 2554), 444: (0, 2556), 161: (0, 2558), 208: (0, 2560), 481: (0, 2561), 173: (0, 2564), 283: (0, 2567), 169: (0, 2568), 25: (0, 1783), 479: (0, 2571), 482: (0, 2572), 201: (0, 2575), 281: (0, 2577), 57: (1, {'@': 437}), 60: (1, {'@': 437})}, 2065: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 699)}, 2066: {126: (0, 741), 146: (1, {'@': 1196})}, 2067: {531: (0, 1354), 530: (0, 1574), 532: (0, 1356), 533: (0, 1360), 534: (0, 1352), 535: (0, 1362)}, 2068: {126: (0, 273), 146: (1, {'@': 1060})}, 2069: {60: (0, 1033)}, 2070: {146: (0, 342)}, 2071: {60: (1, {'@': 1298}), 147: (1, {'@': 1298}), 126: (1, {'@': 1298}), 148: (1, {'@': 1298}), 149: (1, {'@': 1298}), 150: (1, {'@': 1298}), 151: (1, {'@': 1298}), 152: (1, {'@': 1298}), 153: (1, {'@': 1298}), 154: (1, {'@': 1298}), 155: (1, {'@': 1298}), 156: (1, {'@': 1298}), 157: (1, {'@': 1298}), 158: (1, {'@': 1298}), 159: (1, {'@': 1298}), 57: (1, {'@': 1298}), 160: (1, {'@': 1298})}, 2072: {146: (1, {'@': 837}), 126: (1, {'@': 837})}, 2073: {57: (1, {'@': 1000}), 60: (1, {'@': 1000}), 43: (1, {'@': 1000}), 1: (1, {'@': 1000}), 2: (1, {'@': 1000}), 44: (1, {'@': 1000}), 45: (1, {'@': 1000}), 47: (1, {'@': 1000}), 48: (1, {'@': 1000}), 4: (1, {'@': 1000}), 49: (1, {'@': 1000}), 50: (1, {'@': 1000}), 51: (1, {'@': 1000}), 6: (1, {'@': 1000}), 52: (1, {'@': 1000}), 8: (1, {'@': 1000}), 7: (1, {'@': 1000}), 9: (1, {'@': 1000}), 53: (1, {'@': 1000}), 11: (1, {'@': 1000}), 54: (1, {'@': 1000}), 55: (1, {'@': 1000}), 15: (1, {'@': 1000}), 17: (1, {'@': 1000}), 18: (1, {'@': 1000}), 58: (1, {'@': 1000}), 59: (1, {'@': 1000}), 21: (1, {'@': 1000}), 22: (1, {'@': 1000}), 61: (1, {'@': 1000}), 126: (1, {'@': 1000}), 62: (1, {'@': 1000}), 23: (1, {'@': 1000}), 25: (1, {'@': 1000}), 26: (1, {'@': 1000}), 63: (1, {'@': 1000}), 27: (1, {'@': 1000}), 28: (1, {'@': 1000}), 29: (1, {'@': 1000}), 30: (1, {'@': 1000}), 31: (1, {'@': 1000}), 33: (1, {'@': 1000}), 64: (1, {'@': 1000}), 66: (1, {'@': 1000}), 67: (1, {'@': 1000}), 34: (1, {'@': 1000}), 36: (1, {'@': 1000}), 37: (1, {'@': 1000}), 68: (1, {'@': 1000}), 38: (1, {'@': 1000}), 69: (1, {'@': 1000}), 70: (1, {'@': 1000}), 71: (1, {'@': 1000}), 40: (1, {'@': 1000}), 72: (1, {'@': 1000}), 41: (1, {'@': 1000}), 73: (1, {'@': 1000}), 74: (1, {'@': 1000}), 75: (1, {'@': 1000})}, 2074: {60: (1, {'@': 755})}, 2075: {126: (0, 374), 146: (1, {'@': 1054})}, 2076: {374: (1, {'@': 555}), 60: (1, {'@': 555}), 126: (1, {'@': 555}), 57: (1, {'@': 555}), 306: (1, {'@': 555})}, 2077: {60: (0, 361)}, 2078: {60: (1, {'@': 1236}), 147: (1, {'@': 1236}), 126: (1, {'@': 1236}), 148: (1, {'@': 1236}), 149: (1, {'@': 1236}), 150: (1, {'@': 1236}), 151: (1, {'@': 1236}), 152: (1, {'@': 1236}), 153: (1, {'@': 1236}), 154: (1, {'@': 1236}), 155: (1, {'@': 1236}), 156: (1, {'@': 1236}), 157: (1, {'@': 1236}), 158: (1, {'@': 1236}), 159: (1, {'@': 1236}), 57: (1, {'@': 1236}), 160: (1, {'@': 1236})}, 2079: {57: (1, {'@': 740}), 60: (1, {'@': 740})}, 2080: {80: (0, 2414), 194: (0, 1088), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 2081: {60: (1, {'@': 1281}), 147: (1, {'@': 1281}), 126: (1, {'@': 1281}), 148: (1, {'@': 1281}), 149: (1, {'@': 1281}), 150: (1, {'@': 1281}), 151: (1, {'@': 1281}), 152: (1, {'@': 1281}), 153: (1, {'@': 1281}), 154: (1, {'@': 1281}), 155: (1, {'@': 1281}), 156: (1, {'@': 1281}), 157: (1, {'@': 1281}), 158: (1, {'@': 1281}), 159: (1, {'@': 1281}), 57: (1, {'@': 1281}), 160: (1, {'@': 1281})}, 2082: {60: (1, {'@': 754})}, 2083: {60: (1, {'@': 1290}), 147: (1, {'@': 1290}), 126: (1, {'@': 1290}), 148: (1, {'@': 1290}), 149: (1, {'@': 1290}), 150: (1, {'@': 1290}), 151: (1, {'@': 1290}), 152: (1, {'@': 1290}), 153: (1, {'@': 1290}), 154: (1, {'@': 1290}), 155: (1, {'@': 1290}), 156: (1, {'@': 1290}), 157: (1, {'@': 1290}), 158: (1, {'@': 1290}), 159: (1, {'@': 1290}), 57: (1, {'@': 1290}), 160: (1, {'@': 1290})}, 2084: {146: (0, 343)}, 2085: {60: (0, 284)}, 2086: {146: (0, 356)}, 2087: {60: (1, {'@': 1329}), 57: (1, {'@': 1329})}, 2088: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 194: (0, 1095), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 2089: {57: (1, {'@': 1027}), 60: (1, {'@': 1027})}, 2090: {144: (0, 2316), 145: (0, 1080)}, 2091: {156: (0, 43), 159: (0, 42), 153: (0, 41), 148: (0, 48), 186: (0, 40), 151: (0, 39), 112: (0, 38), 187: (0, 32), 188: (0, 34), 189: (0, 30), 190: (0, 29), 191: (0, 37), 147: (0, 28), 60: (1, {'@': 1328}), 146: (1, {'@': 412})}, 2092: {126: (0, 258), 146: (1, {'@': 1053})}, 2093: {177: (1, {'@': 608}), 7: (1, {'@': 608}), 22: (1, {'@': 608}), 60: (1, {'@': 608}), 126: (1, {'@': 608}), 48: (1, {'@': 608}), 72: (1, {'@': 608}), 178: (1, {'@': 608}), 179: (1, {'@': 608}), 49: (1, {'@': 608}), 57: (1, {'@': 608})}, 2094: {177: (1, {'@': 1637}), 7: (1, {'@': 1637}), 22: (1, {'@': 1637}), 60: (1, {'@': 1637}), 126: (1, {'@': 1637}), 48: (1, {'@': 1637}), 72: (1, {'@': 1637}), 178: (1, {'@': 1637}), 179: (1, {'@': 1637}), 49: (1, {'@': 1637}), 57: (1, {'@': 1637})}, 2095: {60: (0, 322)}, 2096: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 1070)}, 2097: {146: (0, 397)}, 2098: {146: (0, 318)}, 2099: {60: (0, 315)}, 2100: {311: (0, 2361), 310: (0, 1609), 314: (0, 2369)}, 2101: {60: (0, 411)}, 2102: {146: (0, 414)}, 2103: {60: (0, 702), 126: (0, 698)}, 2104: {60: (1, {'@': 749})}, 2105: {60: (0, 685)}, 2106: {60: (0, 392)}, 2107: {60: (1, {'@': 748})}, 2108: {146: (0, 1976)}, 2109: {374: (1, {'@': 1623}), 60: (1, {'@': 1623}), 126: (1, {'@': 1623}), 57: (1, {'@': 1623}), 306: (1, {'@': 1623})}, 2110: {126: (0, 401), 146: (1, {'@': 861})}, 2111: {60: (0, 369)}, 2112: {146: (0, 1980)}, 2113: {57: (1, {'@': 766}), 60: (1, {'@': 766})}, 2114: {57: (1, {'@': 552}), 60: (1, {'@': 552})}, 2115: {57: (1, {'@': 764}), 60: (1, {'@': 764})}, 2116: {57: (1, {'@': 848}), 60: (1, {'@': 848})}, 2117: {146: (0, 407)}, 2118: {146: (1, {'@': 862})}, 2119: {126: (1, {'@': 1675}), 146: (1, {'@': 1675})}, 2120: {60: (0, 1978), 146: (1, {'@': 864})}, 2121: {17: (0, 50), 7: (0, 45), 184: (0, 51), 28: (0, 33), 180: (0, 27), 61: (0, 25), 164: (0, 24), 182: (0, 23), 183: (0, 22), 195: (0, 21), 6: (0, 20), 185: (0, 19), 0: (1, {'@': 423}), 3: (1, {'@': 423}), 20: (1, {'@': 423}), 32: (1, {'@': 423}), 65: (1, {'@': 423}), 10: (1, {'@': 423}), 35: (1, {'@': 423}), 12: (1, {'@': 423}), 46: (1, {'@': 423}), 24: (1, {'@': 423}), 14: (1, {'@': 423}), 13: (1, {'@': 423}), 39: (1, {'@': 423}), 42: (1, {'@': 423}), 56: (1, {'@': 423}), 16: (1, {'@': 423}), 5: (1, {'@': 423}), 19: (1, {'@': 423}), 146: (1, {'@': 387}), 60: (1, {'@': 901})}, 2122: {60: (0, 1987)}, 2123: {146: (0, 1989)}, 2124: {112: (0, 309), 146: (1, {'@': 369})}, 2125: {193: (0, 53), 192: (0, 47), 60: (1, {'@': 737}), 146: (1, {'@': 375})}, 2126: {78: (0, 2091), 32: (0, 2121), 77: (0, 2124), 96: (0, 2125), 119: (0, 2128), 315: (0, 66), 316: (0, 67), 79: (0, 2130), 317: (0, 68), 318: (0, 69), 99: (0, 2131), 91: (0, 2135), 19: (0, 2137), 12: (0, 2140), 319: (0, 74), 320: (0, 75), 321: (0, 76), 82: (0, 2145), 322: (0, 77), 323: (0, 78), 111: (0, 2148), 16: (0, 2153), 13: (0, 2156), 118: (0, 2159), 115: (0, 2172), 105: (0, 2176), 324: (0, 89), 83: (0, 2179), 325: (0, 90), 122: (0, 2181), 84: (0, 2184), 85: (0, 2188), 39: (0, 2192), 259: (0, 97), 326: (0, 99), 327: (0, 100), 10: (0, 2196), 114: (0, 2197), 87: (0, 2200), 35: (0, 2204), 328: (0, 103), 124: (0, 2208), 88: (0, 2210), 90: (0, 1028), 102: (0, 1031), 3: (0, 1037), 113: (0, 1043), 65: (0, 1048), 94: (0, 1054), 329: (0, 115), 95: (0, 1060), 330: (0, 117), 331: (0, 118), 0: (0, 1067), 110: (0, 1071), 92: (0, 1076), 332: (0, 1464), 93: (0, 1083), 46: (0, 1085), 333: (0, 1475), 24: (0, 1094), 120: (0, 1100), 98: (0, 1105), 117: (0, 1107), 56: (0, 1114), 334: (0, 1514), 14: (0, 1117), 5: (0, 1123), 335: (0, 1533), 108: (0, 1129), 336: (0, 1539), 20: (0, 1131), 100: (0, 1137), 337: (0, 1547), 103: (0, 1142), 338: (0, 1559), 339: (0, 1564), 106: (0, 1147), 340: (0, 1568), 341: (0, 1586), 342: (0, 1588), 123: (0, 1139), 344: (0, 1593), 109: (0, 1159), 345: (0, 1595), 346: (0, 1597), 347: (0, 1599), 348: (0, 1601), 349: (0, 1613), 350: (0, 1615), 116: (0, 1165), 86: (0, 1168), 351: (0, 1645), 352: (0, 1647), 353: (0, 1649), 354: (0, 1651), 355: (0, 1662), 356: (0, 1663), 357: (0, 1682), 42: (0, 1170), 358: (0, 1700), 343: (0, 1178), 359: (0, 1702), 360: (0, 1705), 361: (0, 1707), 362: (0, 1709), 363: (0, 1720), 364: (0, 1722), 365: (0, 1725), 366: (0, 1726), 367: (0, 1735), 368: (0, 1738), 369: (0, 1740), 370: (0, 1744), 371: (0, 1745), 372: (0, 1748), 373: (0, 1749)}, 2127: {57: (1, {'@': 913}), 60: (1, {'@': 913})}, 2128: {128: (0, 14), 129: (0, 12), 130: (0, 11), 131: (0, 10), 132: (0, 8), 133: (0, 4), 134: (0, 13), 140: (0, 3), 136: (0, 9), 137: (0, 5), 138: (0, 6), 139: (0, 18), 141: (0, 49), 142: (0, 46), 196: (0, 31), 143: (0, 26), 146: (1, {'@': 373})}, 2129: {107: (0, 2409), 112: (0, 2376), 81: (0, 2295), 80: (0, 2414), 194: (0, 1223), 97: (0, 2370), 428: (0, 1297), 89: (0, 2384)}, 2130: {112: (0, 1762), 146: (1, {'@': 365})}, 2131: {36: (0, 15), 197: (0, 16), 146: (1, {'@': 366}), 60: (1, {'@': 531})}, 2132: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 545)}, 2133: {59: (1, {'@': 1409}), 60: (1, {'@': 1409}), 21: (1, {'@': 1409}), 22: (1, {'@': 1409}), 44: (1, {'@': 1409}), 126: (1, {'@': 1409}), 62: (1, {'@': 1409}), 61: (1, {'@': 1409}), 23: (1, {'@': 1409}), 25: (1, {'@': 1409}), 28: (1, {'@': 1409}), 49: (1, {'@': 1409}), 6: (1, {'@': 1409}), 33: (1, {'@': 1409}), 7: (1, {'@': 1409}), 53: (1, {'@': 1409}), 69: (1, {'@': 1409}), 40: (1, {'@': 1409}), 41: (1, {'@': 1409}), 75: (1, {'@': 1409}), 73: (1, {'@': 1409}), 57: (1, {'@': 1409}), 43: (1, {'@': 1409}), 45: (1, {'@': 1409}), 27: (1, {'@': 1409}), 64: (1, {'@': 1409}), 34: (1, {'@': 1409}), 37: (1, {'@': 1409}), 54: (1, {'@': 1409}), 38: (1, {'@': 1409}), 74: (1, {'@': 1409}), 18: (1, {'@': 1409}), 58: (1, {'@': 1409}), 66: (1, {'@': 1409}), 2: (1, {'@': 1409}), 63: (1, {'@': 1409}), 52: (1, {'@': 1409}), 8: (1, {'@': 1409}), 71: (1, {'@': 1409}), 55: (1, {'@': 1409}), 1: (1, {'@': 1409}), 47: (1, {'@': 1409}), 48: (1, {'@': 1409}), 4: (1, {'@': 1409}), 50: (1, {'@': 1409}), 51: (1, {'@': 1409}), 9: (1, {'@': 1409}), 11: (1, {'@': 1409}), 15: (1, {'@': 1409}), 17: (1, {'@': 1409}), 26: (1, {'@': 1409}), 29: (1, {'@': 1409}), 30: (1, {'@': 1409}), 31: (1, {'@': 1409}), 67: (1, {'@': 1409}), 36: (1, {'@': 1409}), 68: (1, {'@': 1409}), 70: (1, {'@': 1409}), 72: (1, {'@': 1409})}, 2134: {305: (0, 1512), 375: (0, 1866), 306: (0, 1770), 374: (0, 140)}, 2135: {60: (1, {'@': 1237}), 146: (1, {'@': 408})}, 2136: {112: (1, {'@': 1301}), 57: (1, {'@': 1301}), 60: (1, {'@': 1301}), 147: (1, {'@': 1301}), 126: (1, {'@': 1301}), 148: (1, {'@': 1301}), 149: (1, {'@': 1301}), 150: (1, {'@': 1301}), 151: (1, {'@': 1301}), 152: (1, {'@': 1301}), 153: (1, {'@': 1301}), 154: (1, {'@': 1301}), 155: (1, {'@': 1301}), 156: (1, {'@': 1301}), 157: (1, {'@': 1301}), 158: (1, {'@': 1301}), 159: (1, {'@': 1301}), 160: (1, {'@': 1301})}, 2137: {198: (0, 393), 22: (0, 389), 53: (0, 387), 33: (0, 383), 7: (0, 45), 199: (0, 379), 44: (0, 358), 41: (0, 372), 62: (0, 367), 21: (0, 366), 59: (0, 363), 200: (0, 395), 180: (0, 359), 201: (0, 354), 183: (0, 351), 202: (0, 350), 164: (0, 347), 75: (0, 341), 203: (0, 402), 204: (0, 304), 49: (0, 335), 205: (0, 334), 28: (0, 33), 206: (0, 330), 61: (0, 25), 23: (0, 327), 185: (0, 324), 207: (0, 320), 208: (0, 303), 209: (0, 1753), 40: (0, 1756), 69: (0, 1760), 73: (0, 1763), 172: (0, 1765), 210: (0, 1769), 211: (0, 1774), 6: (0, 20), 212: (0, 1778), 25: (0, 1783), 213: (0, 1788), 0: (1, {'@': 432}), 3: (1, {'@': 432}), 20: (1, {'@': 432}), 32: (1, {'@': 432}), 65: (1, {'@': 432}), 10: (1, {'@': 432}), 35: (1, {'@': 432}), 12: (1, {'@': 432}), 46: (1, {'@': 432}), 24: (1, {'@': 432}), 14: (1, {'@': 432}), 13: (1, {'@': 432}), 39: (1, {'@': 432}), 42: (1, {'@': 432}), 56: (1, {'@': 432}), 16: (1, {'@': 432}), 5: (1, {'@': 432}), 19: (1, {'@': 432}), 146: (1, {'@': 401})}, 2138: {146: (1, {'@': 1493})}, 2139: {146: (1, {'@': 1466})}, 2140: {204: (0, 1972), 165: (0, 2211), 479: (0, 2215), 53: (0, 387), 33: (0, 383), 63: (0, 2218), 164: (0, 2221), 44: (0, 358), 2: (0, 2225), 55: (0, 2229), 480: (0, 2232), 185: (0, 2239), 481: (0, 2240), 8: (0, 1510), 52: (0, 1498), 28: (0, 33), 210: (0, 2244), 61: (0, 25), 482: (0, 2248), 483: (0, 2251), 290: (0, 2257), 657: (0, 2260), 37: (0, 1828), 71: (0, 2263), 6: (0, 20), 183: (0, 2267), 292: (0, 2274), 172: (0, 2278), 0: (1, {'@': 419}), 3: (1, {'@': 419}), 20: (1, {'@': 419}), 32: (1, {'@': 419}), 65: (1, {'@': 419}), 10: (1, {'@': 419}), 35: (1, {'@': 419}), 12: (1, {'@': 419}), 46: (1, {'@': 419}), 24: (1, {'@': 419}), 14: (1, {'@': 419}), 13: (1, {'@': 419}), 39: (1, {'@': 419}), 42: (1, {'@': 419}), 56: (1, {'@': 419}), 16: (1, {'@': 419}), 5: (1, {'@': 419}), 19: (1, {'@': 419}), 60: (1, {'@': 813}), 146: (1, {'@': 383})}, 2141: {374: (1, {'@': 1626}), 60: (1, {'@': 1626}), 126: (1, {'@': 1626}), 57: (1, {'@': 1626}), 306: (1, {'@': 1626})}, 2142: {57: (1, {'@': 550}), 60: (1, {'@': 550})}, 2143: {60: (0, 1363)}, 2144: {57: (1, {'@': 973}), 60: (1, {'@': 973})}, 2145: {401: (0, 1785), 192: (0, 1791), 400: (0, 1799), 193: (0, 53), 653: (0, 1801), 146: (1, {'@': 381}), 60: (1, {'@': 787})}, 2146: {126: (0, 386), 675: (0, 65), 146: (1, {'@': 1551}), 60: (1, {'@': 1551})}, 2147: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 194: (0, 2069), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 2148: {156: (0, 43), 159: (0, 42), 412: (0, 1496), 154: (0, 1501), 157: (0, 1505), 418: (0, 1507), 153: (0, 41), 152: (0, 1517), 148: (0, 48), 413: (0, 1520), 186: (0, 1525), 149: (0, 1528), 151: (0, 39), 160: (0, 1532), 414: (0, 1538), 158: (0, 1543), 191: (0, 1546), 155: (0, 1549), 150: (0, 1554), 415: (0, 1556), 416: (0, 1560), 147: (0, 28), 187: (0, 1566), 417: (0, 1571), 189: (0, 1575), 419: (0, 1579), 650: (0, 1582), 420: (0, 1587), 188: (0, 1592), 190: (0, 1596), 146: (1, {'@': 411})}, 2149: {126: (1, {'@': 1543}), 146: (1, {'@': 1543}), 60: (1, {'@': 1543})}, 2150: {126: (0, 385), 146: (1, {'@': 556})}, 2151: {126: (0, 176), 146: (1, {'@': 557})}, 2152: {146: (0, 130)}, 2153: {214: (0, 301), 4: (0, 405), 7: (0, 45), 161: (0, 413), 27: (0, 408), 215: (0, 1790), 50: (0, 1792), 26: (0, 1797), 216: (0, 1802), 180: (0, 1807), 38: (0, 1811), 183: (0, 1813), 167: (0, 1817), 28: (0, 33), 61: (0, 25), 47: (0, 1820), 164: (0, 1824), 37: (0, 1828), 45: (0, 1833), 169: (0, 1836), 163: (0, 1842), 165: (0, 1846), 6: (0, 20), 185: (0, 1849), 168: (0, 1853), 217: (0, 1857), 0: (1, {'@': 427}), 3: (1, {'@': 427}), 20: (1, {'@': 427}), 32: (1, {'@': 427}), 65: (1, {'@': 427}), 10: (1, {'@': 427}), 35: (1, {'@': 427}), 12: (1, {'@': 427}), 46: (1, {'@': 427}), 24: (1, {'@': 427}), 14: (1, {'@': 427}), 13: (1, {'@': 427}), 39: (1, {'@': 427}), 42: (1, {'@': 427}), 56: (1, {'@': 427}), 16: (1, {'@': 427}), 5: (1, {'@': 427}), 19: (1, {'@': 427}), 60: (1, {'@': 936}), 146: (1, {'@': 393})}, 2154: {126: (1, {'@': 1610}), 146: (1, {'@': 1610}), 60: (1, {'@': 1610})}, 2155: {60: (1, {'@': 1345}), 57: (1, {'@': 1345})}, 2156: {171: (0, 35), 161: (0, 1867), 53: (0, 387), 4: (0, 405), 29: (0, 1870), 162: (0, 1874), 163: (0, 1879), 27: (0, 408), 164: (0, 1881), 26: (0, 1797), 38: (0, 1811), 218: (0, 1885), 165: (0, 1888), 166: (0, 1893), 167: (0, 1898), 168: (0, 1903), 61: (0, 25), 15: (0, 1909), 67: (0, 1913), 169: (0, 1917), 37: (0, 1828), 45: (0, 1833), 30: (0, 1920), 170: (0, 1924), 172: (0, 1929), 173: (0, 1933), 0: (1, {'@': 421}), 3: (1, {'@': 421}), 20: (1, {'@': 421}), 32: (1, {'@': 421}), 65: (1, {'@': 421}), 10: (1, {'@': 421}), 35: (1, {'@': 421}), 12: (1, {'@': 421}), 46: (1, {'@': 421}), 24: (1, {'@': 421}), 14: (1, {'@': 421}), 13: (1, {'@': 421}), 39: (1, {'@': 421}), 42: (1, {'@': 421}), 56: (1, {'@': 421}), 16: (1, {'@': 421}), 5: (1, {'@': 421}), 19: (1, {'@': 421}), 146: (1, {'@': 385}), 60: (1, {'@': 868})}, 2157: {60: (0, 186)}, 2158: {60: (1, {'@': 1169}), 146: (1, {'@': 1169})}, 2159: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 1830), 12: (0, 1939), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 1957), 78: (0, 1960), 14: (0, 1965), 86: (0, 1968), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 219: (0, 795), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864), 146: (1, {'@': 415})}, 2160: {60: (1, {'@': 1165}), 146: (1, {'@': 1165})}, 2161: {60: (0, 512)}, 2162: {60: (1, {'@': 1162}), 146: (1, {'@': 1162})}, 2163: {60: (1, {'@': 1161}), 146: (1, {'@': 1161})}, 2164: {115: (0, 44), 77: (0, 17), 108: (0, 400), 429: (0, 2540), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 430: (0, 517), 431: (0, 2548), 432: (0, 2552), 96: (0, 789), 82: (0, 791), 98: (0, 793), 433: (0, 2562), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 434: (0, 2565), 435: (0, 2569), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 436: (0, 2573), 437: (0, 2578), 65: (0, 834), 438: (0, 2581), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 86: (0, 2584), 0: (0, 846), 439: (0, 2586), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 440: (0, 2588), 42: (0, 858), 123: (0, 856), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2165: {146: (0, 2559)}, 2166: {60: (0, 1773)}, 2167: {60: (1, {'@': 1166}), 146: (1, {'@': 1166})}, 2168: {60: (0, 969), 146: (0, 934)}, 2169: {60: (1, {'@': 1168}), 146: (1, {'@': 1168})}, 2170: {60: (1, {'@': 1137}), 57: (1, {'@': 1137})}, 2171: {60: (1, {'@': 1160}), 146: (1, {'@': 1160})}, 2172: {112: (0, 7), 220: (0, 869), 197: (0, 870), 221: (0, 872), 36: (0, 15), 222: (0, 874), 223: (0, 876), 224: (0, 878), 225: (0, 879), 226: (0, 883), 227: (0, 885), 228: (0, 887), 229: (0, 889), 146: (1, {'@': 372})}, 2173: {60: (1, {'@': 1163}), 146: (1, {'@': 1163})}, 2174: {112: (1, {'@': 1709}), 89: (1, {'@': 1709}), 97: (1, {'@': 1709}), 107: (1, {'@': 1709}), 126: (1, {'@': 1709}), 146: (1, {'@': 1709}), 60: (1, {'@': 1709})}, 2175: {60: (1, {'@': 1167}), 146: (1, {'@': 1167})}, 2176: {230: (0, 891), 231: (0, 893), 232: (0, 895), 233: (0, 898), 234: (0, 900), 235: (0, 901), 236: (0, 903), 237: (0, 905), 238: (0, 907), 239: (0, 910), 240: (0, 912), 241: (0, 914), 242: (0, 916), 243: (0, 917), 244: (0, 919), 245: (0, 921), 146: (1, {'@': 374})}, 2177: {60: (1, {'@': 1164}), 146: (1, {'@': 1164})}, 2178: {146: (0, 2269)}, 2179: {112: (0, 1734), 146: (1, {'@': 361})}, 2180: {146: (0, 508)}, 2181: {53: (0, 387), 41: (0, 372), 127: (0, 930), 125: (0, 928), 249: (0, 935), 247: (0, 82), 201: (0, 923), 248: (0, 925), 172: (0, 933), 246: (0, 2), 146: (1, {'@': 400}), 60: (1, {'@': 1072})}, 2182: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 86: (0, 467), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2183: {146: (0, 255)}, 2184: {265: (0, 993), 4: (0, 405), 266: (0, 1016), 267: (0, 1017), 112: (0, 1021), 268: (0, 1462), 269: (0, 1465), 67: (0, 1913), 166: (0, 1468), 270: (0, 1470), 30: (0, 1920), 162: (0, 1472), 161: (0, 1476), 271: (0, 1479), 272: (0, 1483), 60: (1, {'@': 612}), 146: (1, {'@': 371})}, 2185: {60: (0, 2488)}, 2186: {115: (0, 44), 77: (0, 17), 507: (0, 2193), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 508: (0, 2194), 116: (0, 780), 46: (0, 781), 510: (0, 2198), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 86: (0, 2195), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 509: (0, 641), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 511: (0, 2187), 124: (0, 864)}, 2187: {112: (0, 2401)}, 2188: {250: (0, 938), 175: (0, 940), 22: (0, 389), 251: (0, 942), 7: (0, 45), 252: (0, 944), 49: (0, 335), 180: (0, 945), 206: (0, 947), 198: (0, 949), 176: (0, 951), 174: (0, 953), 253: (0, 954), 254: (0, 956), 146: (1, {'@': 406})}, 2189: {676: (0, 537), 126: (0, 562), 146: (1, {'@': 1177})}, 2190: {620: (0, 763), 621: (0, 2238), 622: (0, 769)}, 2191: {611: (0, 2103)}, 2192: {180: (0, 88), 7: (0, 45), 0: (1, {'@': 425}), 3: (1, {'@': 425}), 20: (1, {'@': 425}), 32: (1, {'@': 425}), 65: (1, {'@': 425}), 10: (1, {'@': 425}), 35: (1, {'@': 425}), 12: (1, {'@': 425}), 46: (1, {'@': 425}), 24: (1, {'@': 425}), 14: (1, {'@': 425}), 13: (1, {'@': 425}), 39: (1, {'@': 425}), 42: (1, {'@': 425}), 56: (1, {'@': 425}), 16: (1, {'@': 425}), 5: (1, {'@': 425}), 19: (1, {'@': 425}), 60: (1, {'@': 933}), 146: (1, {'@': 391})}, 2193: {112: (0, 2065)}, 2194: {126: (1, {'@': 1178}), 146: (1, {'@': 1178})}, 2195: {126: (1, {'@': 1180}), 146: (1, {'@': 1180})}, 2196: {22: (0, 389), 53: (0, 387), 7: (0, 45), 68: (0, 1724), 70: (0, 1727), 446: (0, 1731), 652: (0, 1739), 444: (0, 1742), 49: (0, 335), 34: (0, 1589), 206: (0, 1747), 198: (0, 1751), 445: (0, 1754), 69: (0, 1760), 172: (0, 1757), 180: (0, 1761), 287: (0, 1764), 200: (0, 1766), 0: (1, {'@': 436}), 3: (1, {'@': 436}), 20: (1, {'@': 436}), 32: (1, {'@': 436}), 65: (1, {'@': 436}), 10: (1, {'@': 436}), 35: (1, {'@': 436}), 12: (1, {'@': 436}), 46: (1, {'@': 436}), 24: (1, {'@': 436}), 14: (1, {'@': 436}), 13: (1, {'@': 436}), 39: (1, {'@': 436}), 42: (1, {'@': 436}), 56: (1, {'@': 436}), 16: (1, {'@': 436}), 5: (1, {'@': 436}), 19: (1, {'@': 436}), 60: (1, {'@': 1182}), 146: (1, {'@': 405})}, 2197: {260: (0, 997), 192: (0, 999), 193: (0, 53), 261: (0, 1005), 262: (0, 1008), 263: (0, 1013), 264: (0, 1014), 146: (1, {'@': 382}), 60: (1, {'@': 794})}, 2198: {126: (1, {'@': 1179}), 146: (1, {'@': 1179})}, 2199: {144: (0, 1928)}, 2200: {400: (0, 1799), 401: (0, 1962), 192: (0, 1970), 193: (0, 53), 658: (0, 1473), 146: (1, {'@': 380})}, 2201: {60: (0, 777)}, 2202: {59: (1, {'@': 1384}), 60: (1, {'@': 1384}), 21: (1, {'@': 1384}), 22: (1, {'@': 1384}), 44: (1, {'@': 1384}), 126: (1, {'@': 1384}), 62: (1, {'@': 1384}), 61: (1, {'@': 1384}), 23: (1, {'@': 1384}), 25: (1, {'@': 1384}), 28: (1, {'@': 1384}), 49: (1, {'@': 1384}), 6: (1, {'@': 1384}), 33: (1, {'@': 1384}), 7: (1, {'@': 1384}), 53: (1, {'@': 1384}), 69: (1, {'@': 1384}), 40: (1, {'@': 1384}), 41: (1, {'@': 1384}), 75: (1, {'@': 1384}), 73: (1, {'@': 1384}), 57: (1, {'@': 1384}), 174: (1, {'@': 1384}), 175: (1, {'@': 1384}), 176: (1, {'@': 1384}), 177: (1, {'@': 1384}), 48: (1, {'@': 1384}), 72: (1, {'@': 1384}), 178: (1, {'@': 1384}), 179: (1, {'@': 1384}), 64: (1, {'@': 1384}), 34: (1, {'@': 1384}), 54: (1, {'@': 1384}), 18: (1, {'@': 1384}), 43: (1, {'@': 1384}), 1: (1, {'@': 1384}), 2: (1, {'@': 1384}), 45: (1, {'@': 1384}), 47: (1, {'@': 1384}), 4: (1, {'@': 1384}), 50: (1, {'@': 1384}), 51: (1, {'@': 1384}), 52: (1, {'@': 1384}), 8: (1, {'@': 1384}), 9: (1, {'@': 1384}), 11: (1, {'@': 1384}), 55: (1, {'@': 1384}), 15: (1, {'@': 1384}), 17: (1, {'@': 1384}), 58: (1, {'@': 1384}), 26: (1, {'@': 1384}), 63: (1, {'@': 1384}), 27: (1, {'@': 1384}), 29: (1, {'@': 1384}), 30: (1, {'@': 1384}), 31: (1, {'@': 1384}), 66: (1, {'@': 1384}), 67: (1, {'@': 1384}), 36: (1, {'@': 1384}), 37: (1, {'@': 1384}), 68: (1, {'@': 1384}), 38: (1, {'@': 1384}), 70: (1, {'@': 1384}), 71: (1, {'@': 1384}), 74: (1, {'@': 1384})}, 2203: {60: (1, {'@': 1294})}, 2204: {22: (0, 389), 53: (0, 387), 18: (0, 1581), 172: (0, 1872), 33: (0, 383), 64: (0, 1537), 200: (0, 1876), 44: (0, 358), 183: (0, 1880), 62: (0, 367), 21: (0, 366), 164: (0, 1883), 287: (0, 1886), 204: (0, 1889), 75: (0, 341), 34: (0, 1589), 28: (0, 33), 61: (0, 25), 476: (0, 1894), 208: (0, 1904), 205: (0, 1907), 207: (0, 1912), 280: (0, 1916), 213: (0, 1919), 54: (0, 1598), 283: (0, 1922), 40: (0, 1756), 69: (0, 1760), 656: (0, 1927), 185: (0, 1932), 211: (0, 1936), 210: (0, 1941), 206: (0, 1946), 73: (0, 1763), 6: (0, 20), 286: (0, 1951), 0: (1, {'@': 430}), 3: (1, {'@': 430}), 20: (1, {'@': 430}), 32: (1, {'@': 430}), 65: (1, {'@': 430}), 10: (1, {'@': 430}), 35: (1, {'@': 430}), 12: (1, {'@': 430}), 46: (1, {'@': 430}), 24: (1, {'@': 430}), 14: (1, {'@': 430}), 13: (1, {'@': 430}), 39: (1, {'@': 430}), 42: (1, {'@': 430}), 56: (1, {'@': 430}), 16: (1, {'@': 430}), 5: (1, {'@': 430}), 19: (1, {'@': 430}), 146: (1, {'@': 396}), 60: (1, {'@': 1005})}, 2205: {177: (1, {'@': 1635}), 7: (1, {'@': 1635}), 22: (1, {'@': 1635}), 60: (1, {'@': 1635}), 126: (1, {'@': 1635}), 48: (1, {'@': 1635}), 72: (1, {'@': 1635}), 178: (1, {'@': 1635}), 179: (1, {'@': 1635}), 49: (1, {'@': 1635}), 57: (1, {'@': 1635})}, 2206: {57: (1, {'@': 514}), 60: (1, {'@': 514}), 126: (1, {'@': 514}), 522: (1, {'@': 514})}, 2207: {177: (1, {'@': 1638}), 7: (1, {'@': 1638}), 22: (1, {'@': 1638}), 60: (1, {'@': 1638}), 126: (1, {'@': 1638}), 48: (1, {'@': 1638}), 72: (1, {'@': 1638}), 178: (1, {'@': 1638}), 179: (1, {'@': 1638}), 49: (1, {'@': 1638}), 57: (1, {'@': 1638})}, 2208: {112: (0, 313), 60: (1, {'@': 1234}), 146: (1, {'@': 407})}, 2209: {22: (0, 389), 48: (0, 1843), 7: (0, 45), 390: (0, 1819), 177: (0, 1812), 49: (0, 335), 391: (0, 1837), 179: (0, 1835), 206: (0, 1935), 393: (0, 2094), 198: (0, 1940), 72: (0, 1882), 392: (0, 1945), 178: (0, 1950), 180: (0, 1955), 394: (0, 1961), 395: (0, 1966)}, 2210: {22: (0, 389), 53: (0, 387), 655: (0, 1771), 205: (0, 1825), 447: (0, 1829), 62: (0, 367), 206: (0, 1838), 172: (0, 1841), 146: (1, {'@': 398})}, 2211: {2: (1, {'@': 825}), 60: (1, {'@': 825}), 44: (1, {'@': 825}), 61: (1, {'@': 825}), 126: (1, {'@': 825}), 63: (1, {'@': 825}), 28: (1, {'@': 825}), 33: (1, {'@': 825}), 6: (1, {'@': 825}), 52: (1, {'@': 825}), 8: (1, {'@': 825}), 53: (1, {'@': 825}), 37: (1, {'@': 825}), 71: (1, {'@': 825}), 55: (1, {'@': 825}), 57: (1, {'@': 825})}, 2212: {161: (0, 1867), 53: (0, 387), 4: (0, 405), 29: (0, 1870), 162: (0, 1874), 163: (0, 1879), 27: (0, 408), 171: (0, 2392), 164: (0, 1881), 26: (0, 1797), 38: (0, 1811), 165: (0, 1888), 166: (0, 1893), 167: (0, 1898), 168: (0, 1903), 61: (0, 25), 15: (0, 1909), 67: (0, 1913), 169: (0, 1917), 37: (0, 1828), 45: (0, 1833), 30: (0, 1920), 170: (0, 1924), 172: (0, 1929), 173: (0, 1933)}, 2213: {6: (1, {'@': 1671}), 60: (1, {'@': 1671}), 7: (1, {'@': 1671}), 126: (1, {'@': 1671}), 61: (1, {'@': 1671}), 45: (1, {'@': 1671}), 37: (1, {'@': 1671}), 38: (1, {'@': 1671}), 47: (1, {'@': 1671}), 26: (1, {'@': 1671}), 27: (1, {'@': 1671}), 4: (1, {'@': 1671}), 28: (1, {'@': 1671}), 50: (1, {'@': 1671}), 57: (1, {'@': 1671})}, 2214: {60: (0, 2033)}, 2215: {2: (1, {'@': 826}), 60: (1, {'@': 826}), 44: (1, {'@': 826}), 61: (1, {'@': 826}), 126: (1, {'@': 826}), 63: (1, {'@': 826}), 28: (1, {'@': 826}), 33: (1, {'@': 826}), 6: (1, {'@': 826}), 52: (1, {'@': 826}), 8: (1, {'@': 826}), 53: (1, {'@': 826}), 37: (1, {'@': 826}), 71: (1, {'@': 826}), 55: (1, {'@': 826}), 57: (1, {'@': 826})}, 2216: {126: (0, 961), 146: (1, {'@': 1463})}, 2217: {80: (0, 2414), 194: (0, 416), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 2218: {112: (0, 277)}, 2219: {57: (1, {'@': 870}), 60: (1, {'@': 870})}, 2220: {126: (0, 978), 146: (1, {'@': 1464})}, 2221: {2: (1, {'@': 823}), 60: (1, {'@': 823}), 44: (1, {'@': 823}), 61: (1, {'@': 823}), 126: (1, {'@': 823}), 63: (1, {'@': 823}), 28: (1, {'@': 823}), 33: (1, {'@': 823}), 6: (1, {'@': 823}), 52: (1, {'@': 823}), 8: (1, {'@': 823}), 53: (1, {'@': 823}), 37: (1, {'@': 823}), 71: (1, {'@': 823}), 55: (1, {'@': 823}), 57: (1, {'@': 823})}, 2222: {60: (1, {'@': 1363}), 57: (1, {'@': 1363})}, 2223: {60: (0, 456)}, 2224: {126: (1, {'@': 583}), 60: (1, {'@': 583})}, 2225: {112: (0, 321), 2: (1, {'@': 845}), 60: (1, {'@': 845}), 44: (1, {'@': 845}), 61: (1, {'@': 845}), 126: (1, {'@': 845}), 63: (1, {'@': 845}), 28: (1, {'@': 845}), 33: (1, {'@': 845}), 6: (1, {'@': 845}), 52: (1, {'@': 845}), 8: (1, {'@': 845}), 53: (1, {'@': 845}), 37: (1, {'@': 845}), 71: (1, {'@': 845}), 55: (1, {'@': 845}), 57: (1, {'@': 845}), 43: (1, {'@': 845}), 1: (1, {'@': 845}), 45: (1, {'@': 845}), 47: (1, {'@': 845}), 48: (1, {'@': 845}), 4: (1, {'@': 845}), 49: (1, {'@': 845}), 50: (1, {'@': 845}), 51: (1, {'@': 845}), 7: (1, {'@': 845}), 9: (1, {'@': 845}), 11: (1, {'@': 845}), 54: (1, {'@': 845}), 15: (1, {'@': 845}), 17: (1, {'@': 845}), 18: (1, {'@': 845}), 58: (1, {'@': 845}), 59: (1, {'@': 845}), 21: (1, {'@': 845}), 22: (1, {'@': 845}), 62: (1, {'@': 845}), 23: (1, {'@': 845}), 25: (1, {'@': 845}), 26: (1, {'@': 845}), 27: (1, {'@': 845}), 29: (1, {'@': 845}), 30: (1, {'@': 845}), 31: (1, {'@': 845}), 64: (1, {'@': 845}), 66: (1, {'@': 845}), 67: (1, {'@': 845}), 34: (1, {'@': 845}), 36: (1, {'@': 845}), 68: (1, {'@': 845}), 38: (1, {'@': 845}), 69: (1, {'@': 845}), 70: (1, {'@': 845}), 40: (1, {'@': 845}), 72: (1, {'@': 845}), 41: (1, {'@': 845}), 73: (1, {'@': 845}), 74: (1, {'@': 845}), 75: (1, {'@': 845})}, 2226: {126: (1, {'@': 584}), 60: (1, {'@': 584})}, 2227: {144: (0, 2316), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 383: (0, 2420), 116: (0, 780), 382: (0, 2422), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 677: (0, 2423), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 86: (0, 2426), 119: (0, 836), 120: (0, 840), 106: (0, 838), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 145: (0, 2428), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2228: {4: (0, 405), 7: (0, 45), 161: (0, 413), 27: (0, 408), 215: (0, 1790), 50: (0, 1792), 26: (0, 1797), 180: (0, 1807), 38: (0, 1811), 183: (0, 1813), 167: (0, 1817), 28: (0, 33), 61: (0, 25), 47: (0, 1820), 164: (0, 1824), 37: (0, 1828), 45: (0, 1833), 169: (0, 1836), 163: (0, 1842), 165: (0, 1846), 6: (0, 20), 185: (0, 1849), 168: (0, 1853), 217: (0, 1857), 214: (0, 982)}, 2229: {112: (0, 326)}, 2230: {57: (1, {'@': 1074}), 60: (1, {'@': 1074})}, 2231: {500: (1, {'@': 541}), 60: (1, {'@': 541}), 501: (1, {'@': 541}), 126: (1, {'@': 541}), 57: (1, {'@': 541})}, 2232: {204: (0, 1972), 165: (0, 2211), 479: (0, 2215), 53: (0, 387), 33: (0, 383), 63: (0, 2218), 678: (0, 365), 164: (0, 2221), 44: (0, 358), 2: (0, 2225), 480: (0, 371), 55: (0, 2229), 185: (0, 2239), 481: (0, 2240), 8: (0, 1510), 52: (0, 1498), 28: (0, 33), 210: (0, 2244), 126: (0, 373), 61: (0, 25), 482: (0, 2248), 483: (0, 2251), 290: (0, 2257), 37: (0, 1828), 71: (0, 2263), 6: (0, 20), 183: (0, 2267), 292: (0, 2274), 172: (0, 2278), 57: (1, {'@': 815}), 60: (1, {'@': 815})}, 2233: {144: (0, 2316), 86: (0, 2419), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 145: (0, 2430), 105: (0, 830), 113: (0, 828), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2234: {41: (0, 372), 246: (0, 2), 247: (0, 82), 201: (0, 923), 125: (0, 928), 53: (0, 387), 248: (0, 2502), 127: (0, 930), 172: (0, 933)}, 2235: {6: (1, {'@': 1674}), 60: (1, {'@': 1674}), 7: (1, {'@': 1674}), 126: (1, {'@': 1674}), 61: (1, {'@': 1674}), 45: (1, {'@': 1674}), 37: (1, {'@': 1674}), 38: (1, {'@': 1674}), 47: (1, {'@': 1674}), 26: (1, {'@': 1674}), 27: (1, {'@': 1674}), 4: (1, {'@': 1674}), 28: (1, {'@': 1674}), 50: (1, {'@': 1674}), 57: (1, {'@': 1674})}, 2236: {146: (1, {'@': 572})}, 2237: {146: (0, 946)}, 2238: {60: (0, 2306)}, 2239: {2: (1, {'@': 816}), 60: (1, {'@': 816}), 44: (1, {'@': 816}), 61: (1, {'@': 816}), 126: (1, {'@': 816}), 63: (1, {'@': 816}), 28: (1, {'@': 816}), 33: (1, {'@': 816}), 6: (1, {'@': 816}), 52: (1, {'@': 816}), 8: (1, {'@': 816}), 53: (1, {'@': 816}), 37: (1, {'@': 816}), 71: (1, {'@': 816}), 55: (1, {'@': 816}), 57: (1, {'@': 816})}, 2240: {2: (1, {'@': 824}), 60: (1, {'@': 824}), 44: (1, {'@': 824}), 61: (1, {'@': 824}), 126: (1, {'@': 824}), 63: (1, {'@': 824}), 28: (1, {'@': 824}), 33: (1, {'@': 824}), 6: (1, {'@': 824}), 52: (1, {'@': 824}), 8: (1, {'@': 824}), 53: (1, {'@': 824}), 37: (1, {'@': 824}), 71: (1, {'@': 824}), 55: (1, {'@': 824}), 57: (1, {'@': 824})}, 2241: {126: (1, {'@': 1467}), 146: (1, {'@': 1467})}, 2242: {146: (0, 196), 499: (0, 189), 126: (0, 191), 60: (1, {'@': 719})}, 2243: {60: (0, 2338)}, 2244: {2: (1, {'@': 828}), 60: (1, {'@': 828}), 44: (1, {'@': 828}), 61: (1, {'@': 828}), 126: (1, {'@': 828}), 63: (1, {'@': 828}), 28: (1, {'@': 828}), 33: (1, {'@': 828}), 6: (1, {'@': 828}), 52: (1, {'@': 828}), 8: (1, {'@': 828}), 53: (1, {'@': 828}), 37: (1, {'@': 828}), 71: (1, {'@': 828}), 55: (1, {'@': 828}), 57: (1, {'@': 828})}, 2245: {126: (1, {'@': 969}), 60: (1, {'@': 969})}, 2246: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 86: (0, 2441), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 194: (0, 2443), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 2247: {60: (0, 2345)}, 2248: {2: (1, {'@': 822}), 60: (1, {'@': 822}), 44: (1, {'@': 822}), 61: (1, {'@': 822}), 126: (1, {'@': 822}), 63: (1, {'@': 822}), 28: (1, {'@': 822}), 33: (1, {'@': 822}), 6: (1, {'@': 822}), 52: (1, {'@': 822}), 8: (1, {'@': 822}), 53: (1, {'@': 822}), 37: (1, {'@': 822}), 71: (1, {'@': 822}), 55: (1, {'@': 822}), 57: (1, {'@': 822})}, 2249: {126: (1, {'@': 966}), 60: (1, {'@': 966})}, 2250: {60: (1, {'@': 758}), 57: (1, {'@': 758})}, 2251: {2: (1, {'@': 817}), 60: (1, {'@': 817}), 44: (1, {'@': 817}), 61: (1, {'@': 817}), 126: (1, {'@': 817}), 63: (1, {'@': 817}), 28: (1, {'@': 817}), 33: (1, {'@': 817}), 6: (1, {'@': 817}), 52: (1, {'@': 817}), 8: (1, {'@': 817}), 53: (1, {'@': 817}), 37: (1, {'@': 817}), 71: (1, {'@': 817}), 55: (1, {'@': 817}), 57: (1, {'@': 817})}, 2252: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 303: (0, 352), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 86: (0, 2432), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2253: {126: (1, {'@': 970}), 60: (1, {'@': 970})}, 2254: {146: (1, {'@': 1336})}, 2255: {197: (0, 870), 220: (0, 869), 221: (0, 872), 36: (0, 15), 222: (0, 874), 223: (0, 876), 229: (0, 889), 227: (0, 885), 228: (0, 887), 226: (0, 883), 225: (0, 2444)}, 2256: {60: (0, 2340)}, 2257: {2: (1, {'@': 827}), 60: (1, {'@': 827}), 44: (1, {'@': 827}), 61: (1, {'@': 827}), 126: (1, {'@': 827}), 63: (1, {'@': 827}), 28: (1, {'@': 827}), 33: (1, {'@': 827}), 6: (1, {'@': 827}), 52: (1, {'@': 827}), 8: (1, {'@': 827}), 53: (1, {'@': 827}), 37: (1, {'@': 827}), 71: (1, {'@': 827}), 55: (1, {'@': 827}), 57: (1, {'@': 827})}, 2258: {126: (1, {'@': 960}), 146: (1, {'@': 960})}, 2259: {146: (1, {'@': 1337})}, 2260: {60: (1, {'@': 812}), 57: (1, {'@': 812})}, 2261: {679: (0, 987), 126: (0, 988), 146: (1, {'@': 959})}, 2262: {60: (1, {'@': 1646}), 126: (1, {'@': 1646}), 222: (1, {'@': 1646}), 220: (1, {'@': 1646}), 36: (1, {'@': 1646}), 221: (1, {'@': 1646}), 223: (1, {'@': 1646}), 57: (1, {'@': 1646})}, 2263: {112: (0, 349)}, 2264: {220: (0, 869), 197: (0, 870), 221: (0, 872), 36: (0, 15), 222: (0, 874), 223: (0, 876), 225: (0, 2447), 226: (0, 883), 126: (0, 2448), 227: (0, 885), 228: (0, 887), 229: (0, 889), 57: (1, {'@': 651}), 60: (1, {'@': 651})}, 2265: {255: (0, 1221), 256: (0, 1373)}, 2266: {57: (1, {'@': 1245}), 60: (1, {'@': 1245}), 126: (1, {'@': 1245}), 6: (1, {'@': 1245}), 469: (1, {'@': 1245})}, 2267: {2: (1, {'@': 819}), 60: (1, {'@': 819}), 44: (1, {'@': 819}), 61: (1, {'@': 819}), 126: (1, {'@': 819}), 63: (1, {'@': 819}), 28: (1, {'@': 819}), 33: (1, {'@': 819}), 6: (1, {'@': 819}), 52: (1, {'@': 819}), 8: (1, {'@': 819}), 53: (1, {'@': 819}), 37: (1, {'@': 819}), 71: (1, {'@': 819}), 55: (1, {'@': 819}), 57: (1, {'@': 819})}, 2268: {126: (1, {'@': 964}), 146: (1, {'@': 964})}, 2269: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 771)}, 2270: {126: (1, {'@': 1609}), 441: (1, {'@': 1609})}, 2271: {144: (0, 2535), 115: (0, 44), 77: (0, 17), 108: (0, 400), 429: (0, 2540), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 680: (0, 2544), 431: (0, 2548), 432: (0, 2552), 430: (0, 2555), 96: (0, 789), 82: (0, 791), 98: (0, 793), 433: (0, 2562), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 434: (0, 2565), 435: (0, 2569), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 436: (0, 2573), 437: (0, 2578), 65: (0, 834), 438: (0, 2581), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 86: (0, 2584), 0: (0, 846), 439: (0, 2586), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 440: (0, 2588), 42: (0, 858), 123: (0, 856), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2272: {126: (0, 2217), 60: (0, 994)}, 2273: {441: (1, {'@': 1744}), 126: (1, {'@': 1744})}, 2274: {2: (1, {'@': 821}), 60: (1, {'@': 821}), 44: (1, {'@': 821}), 61: (1, {'@': 821}), 126: (1, {'@': 821}), 63: (1, {'@': 821}), 28: (1, {'@': 821}), 33: (1, {'@': 821}), 6: (1, {'@': 821}), 52: (1, {'@': 821}), 8: (1, {'@': 821}), 53: (1, {'@': 821}), 37: (1, {'@': 821}), 71: (1, {'@': 821}), 55: (1, {'@': 821}), 57: (1, {'@': 821})}, 2275: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 86: (0, 2497), 194: (0, 2499), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2276: {126: (1, {'@': 965}), 146: (1, {'@': 965})}, 2277: {441: (1, {'@': 1743}), 126: (1, {'@': 1743})}, 2278: {2: (1, {'@': 820}), 60: (1, {'@': 820}), 44: (1, {'@': 820}), 61: (1, {'@': 820}), 126: (1, {'@': 820}), 63: (1, {'@': 820}), 28: (1, {'@': 820}), 33: (1, {'@': 820}), 6: (1, {'@': 820}), 52: (1, {'@': 820}), 8: (1, {'@': 820}), 53: (1, {'@': 820}), 37: (1, {'@': 820}), 71: (1, {'@': 820}), 55: (1, {'@': 820}), 57: (1, {'@': 820})}, 2279: {230: (0, 891), 231: (0, 893), 234: (0, 900), 235: (0, 901), 236: (0, 903), 237: (0, 905), 238: (0, 907), 239: (0, 910), 240: (0, 912), 241: (0, 914), 242: (0, 916), 232: (0, 2463), 243: (0, 917), 244: (0, 919), 245: (0, 921)}, 2280: {146: (0, 996)}, 2281: {146: (0, 2348), 126: (1, {'@': 1571}), 60: (1, {'@': 1571})}, 2282: {112: (0, 2339)}, 2283: {126: (1, {'@': 963}), 146: (1, {'@': 963})}, 2284: {60: (1, {'@': 1238}), 57: (1, {'@': 1238})}, 2285: {126: (1, {'@': 1608}), 441: (1, {'@': 1608})}, 2286: {126: (1, {'@': 962}), 146: (1, {'@': 962})}, 2287: {230: (0, 891), 232: (0, 2466), 231: (0, 893), 234: (0, 900), 235: (0, 901), 236: (0, 903), 237: (0, 905), 238: (0, 907), 239: (0, 910), 126: (0, 2467), 240: (0, 912), 241: (0, 914), 242: (0, 916), 243: (0, 917), 244: (0, 919), 245: (0, 921), 57: (1, {'@': 707}), 60: (1, {'@': 707})}, 2288: {185: (0, 311), 469: (0, 2282), 477: (0, 382), 126: (0, 357), 6: (0, 20), 478: (0, 2296), 60: (1, {'@': 1242}), 57: (1, {'@': 1242})}, 2289: {230: (1, {'@': 1654}), 60: (1, {'@': 1654}), 235: (1, {'@': 1654}), 240: (1, {'@': 1654}), 126: (1, {'@': 1654}), 231: (1, {'@': 1654}), 234: (1, {'@': 1654}), 57: (1, {'@': 1654}), 241: (1, {'@': 1654}), 243: (1, {'@': 1654})}, 2290: {500: (1, {'@': 543}), 60: (1, {'@': 543}), 501: (1, {'@': 543}), 126: (1, {'@': 543}), 57: (1, {'@': 543})}, 2291: {126: (1, {'@': 968}), 60: (1, {'@': 968})}, 2292: {529: (0, 745), 501: (0, 1985), 500: (0, 2010), 681: (0, 765), 528: (0, 2454), 126: (0, 775), 527: (0, 2231), 57: (1, {'@': 540}), 60: (1, {'@': 540})}, 2293: {500: (1, {'@': 545}), 60: (1, {'@': 545}), 501: (1, {'@': 545}), 126: (1, {'@': 545}), 57: (1, {'@': 545})}, 2294: {126: (1, {'@': 961}), 146: (1, {'@': 961})}, 2295: {97: (0, 2043), 112: (0, 2049), 89: (0, 2025), 107: (0, 2013), 126: (1, {'@': 1539}), 146: (1, {'@': 1539}), 60: (1, {'@': 1539})}, 2296: {57: (1, {'@': 1244}), 60: (1, {'@': 1244}), 126: (1, {'@': 1244}), 6: (1, {'@': 1244}), 469: (1, {'@': 1244})}, 2297: {81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 76: (0, 2355), 80: (0, 2149)}, 2298: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 194: (0, 2506), 85: (0, 816), 111: (0, 821), 20: (0, 822), 102: (0, 823), 86: (0, 2509), 103: (0, 825), 14: (0, 399), 118: (0, 819), 10: (0, 826), 100: (0, 817), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 2299: {126: (1, {'@': 967}), 60: (1, {'@': 967})}, 2300: {146: (1, {'@': 892}), 126: (1, {'@': 892})}, 2301: {144: (0, 2316), 145: (0, 1250)}, 2302: {60: (1, {'@': 649}), 57: (1, {'@': 649})}, 2303: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 194: (0, 2358), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 2304: {146: (1, {'@': 893}), 126: (1, {'@': 893})}, 2305: {57: (1, {'@': 789}), 60: (1, {'@': 789})}, 2306: {515: (1, {'@': 577}), 517: (1, {'@': 577}), 60: (1, {'@': 577}), 126: (1, {'@': 577}), 514: (1, {'@': 577}), 57: (1, {'@': 577})}, 2307: {146: (0, 974)}, 2308: {144: (0, 2316), 145: (0, 1035)}, 2309: {81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 76: (0, 2360), 112: (0, 2376), 97: (0, 2370), 80: (0, 2149)}, 2310: {57: (1, {'@': 765}), 60: (1, {'@': 765})}, 2311: {60: (0, 1003)}, 2312: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 144: (0, 2525), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 86: (0, 2527), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2313: {126: (0, 1004), 146: (1, {'@': 889})}, 2314: {126: (0, 924)}, 2315: {81: (0, 2295), 107: (0, 2409), 76: (0, 2362), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 80: (0, 2149)}, 2316: {126: (0, 1027), 682: (0, 1030), 60: (1, {'@': 1545}), 146: (1, {'@': 1545})}, 2317: {126: (1, {'@': 1441})}, 2318: {144: (0, 2316), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 86: (0, 1032), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 145: (0, 1045), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2319: {57: (1, {'@': 1209}), 60: (1, {'@': 1209})}, 2320: {146: (0, 1001)}, 2321: {250: (0, 938), 175: (0, 940), 22: (0, 389), 7: (0, 45), 49: (0, 335), 251: (0, 2531), 180: (0, 945), 206: (0, 947), 198: (0, 949), 174: (0, 953), 253: (0, 954), 176: (0, 951), 254: (0, 956)}, 2322: {126: (1, {'@': 1632}), 60: (1, {'@': 1632})}, 2323: {60: (0, 998)}, 2324: {431: (0, 2224), 660: (0, 1914), 435: (0, 2226)}, 2325: {57: (1, {'@': 798}), 60: (1, {'@': 798})}, 2326: {60: (0, 1011)}, 2327: {57: (1, {'@': 1028}), 60: (1, {'@': 1028})}, 2328: {146: (0, 1012)}, 2329: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 86: (0, 1608), 46: (0, 781), 531: (0, 262), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 540: (0, 362), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 542: (0, 1023), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 541: (0, 1024), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2330: {60: (0, 2352), 126: (0, 2366)}, 2331: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 194: (0, 2111), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 86: (0, 2112), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2332: {126: (1, {'@': 582}), 60: (1, {'@': 582})}, 2333: {144: (0, 2316), 145: (0, 1036)}, 2334: {112: (0, 1018)}, 2335: {60: (0, 2421)}, 2336: {683: (0, 1019), 126: (0, 1020)}, 2337: {144: (0, 2316), 145: (0, 1038)}, 2338: {515: (1, {'@': 570}), 517: (1, {'@': 570}), 60: (1, {'@': 570}), 126: (1, {'@': 570}), 514: (1, {'@': 570}), 57: (1, {'@': 570})}, 2339: {456: (0, 212), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 461: (0, 219), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 458: (0, 215), 95: (0, 786), 12: (0, 396), 5: (0, 787), 459: (0, 216), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 463: (0, 224), 32: (0, 807), 83: (0, 809), 86: (0, 377), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 460: (0, 693), 10: (0, 826), 462: (0, 223), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 454: (0, 188), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 455: (0, 210), 457: (0, 213), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 144: (0, 221), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2340: {515: (1, {'@': 585}), 517: (1, {'@': 585}), 60: (1, {'@': 585}), 126: (1, {'@': 585}), 514: (1, {'@': 585}), 57: (1, {'@': 585})}, 2341: {126: (1, {'@': 1439})}, 2342: {282: (0, 2089), 53: (0, 387), 18: (0, 1581), 164: (0, 1635), 33: (0, 383), 74: (0, 1616), 64: (0, 1537), 44: (0, 358), 41: (0, 372), 21: (0, 366), 27: (0, 408), 172: (0, 1620), 286: (0, 1640), 280: (0, 1542), 169: (0, 1657), 283: (0, 1585), 75: (0, 341), 38: (0, 1811), 167: (0, 1625), 281: (0, 1545), 28: (0, 33), 43: (0, 1548), 61: (0, 25), 34: (0, 1589), 284: (0, 1594), 165: (0, 1553), 54: (0, 1598), 37: (0, 1828), 40: (0, 1756), 69: (0, 1760), 45: (0, 1833), 204: (0, 1565), 6: (0, 20), 185: (0, 1569), 207: (0, 1646), 200: (0, 1627), 211: (0, 1602), 208: (0, 1573), 183: (0, 1607), 201: (0, 1650), 287: (0, 1654), 168: (0, 1577), 210: (0, 1631)}, 2343: {126: (1, {'@': 1438})}, 2344: {60: (0, 1026)}, 2345: {57: (1, {'@': 1332}), 60: (1, {'@': 1332})}, 2346: {144: (0, 2316), 145: (0, 1042)}, 2347: {126: (1, {'@': 1437})}, 2348: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370), 194: (0, 2375)}, 2349: {77: (0, 17), 194: (0, 1977), 78: (0, 1960), 448: (0, 2042), 79: (0, 1973), 12: (0, 396), 81: (0, 2295), 82: (0, 791), 86: (0, 2068), 83: (0, 809), 84: (0, 811), 85: (0, 816), 10: (0, 826), 684: (0, 2070), 87: (0, 842), 35: (0, 844), 88: (0, 848), 89: (0, 2384), 90: (0, 853), 91: (0, 863), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 56: (0, 783), 95: (0, 786), 96: (0, 789), 97: (0, 2370), 98: (0, 793), 19: (0, 800), 13: (0, 802), 32: (0, 807), 99: (0, 812), 100: (0, 817), 20: (0, 822), 102: (0, 823), 103: (0, 825), 105: (0, 830), 65: (0, 834), 106: (0, 838), 107: (0, 2409), 108: (0, 400), 109: (0, 390), 46: (0, 781), 80: (0, 2414), 110: (0, 799), 111: (0, 821), 14: (0, 399), 112: (0, 2376), 113: (0, 828), 114: (0, 832), 0: (0, 846), 42: (0, 858), 39: (0, 860), 115: (0, 44), 116: (0, 780), 311: (0, 2072), 5: (0, 787), 117: (0, 804), 24: (0, 814), 118: (0, 819), 119: (0, 836), 120: (0, 840), 122: (0, 850), 3: (0, 855), 123: (0, 856), 124: (0, 864)}, 2350: {126: (0, 1006)}, 2351: {126: (1, {'@': 1440})}, 2352: {126: (1, {'@': 581}), 60: (1, {'@': 581})}, 2353: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 86: (0, 296), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 466: (0, 1998), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 464: (0, 1982), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 465: (0, 1996), 124: (0, 864)}, 2354: {126: (1, {'@': 1442})}, 2355: {60: (0, 2373)}, 2356: {146: (0, 990)}, 2357: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 86: (0, 1057), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 118: (0, 819), 10: (0, 826), 100: (0, 817), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 194: (0, 1059), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 2358: {60: (0, 2371)}, 2359: {126: (0, 121)}, 2360: {60: (0, 2378)}, 2361: {126: (1, {'@': 1456})}, 2362: {60: (0, 2382)}, 2363: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 194: (0, 1049), 79: (0, 1973), 116: (0, 780), 86: (0, 1051), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2364: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 86: (0, 2098), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 194: (0, 2099), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2365: {126: (0, 1015)}, 2366: {431: (0, 2224), 660: (0, 2386), 435: (0, 2226)}, 2367: {144: (0, 2316), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 86: (0, 2007), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 145: (0, 1983), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2368: {126: (0, 992)}, 2369: {126: (1, {'@': 1455})}, 2370: {112: (1, {'@': 1701}), 89: (1, {'@': 1701}), 97: (1, {'@': 1701}), 107: (1, {'@': 1701}), 126: (1, {'@': 1701}), 146: (1, {'@': 1701}), 60: (1, {'@': 1701})}, 2371: {57: (1, {'@': 515}), 60: (1, {'@': 515}), 126: (1, {'@': 515}), 536: (1, {'@': 515})}, 2372: {126: (0, 129)}, 2373: {57: (1, {'@': 513}), 60: (1, {'@': 513}), 126: (1, {'@': 513}), 522: (1, {'@': 513})}, 2374: {685: (0, 2163), 618: (0, 2160), 586: (0, 2169), 573: (0, 2167), 587: (0, 2158), 588: (0, 2162), 686: (0, 2168), 495: (0, 2171), 687: (0, 2173), 584: (0, 2175), 379: (0, 2177)}, 2375: {126: (1, {'@': 1570}), 60: (1, {'@': 1570})}, 2376: {112: (0, 2001), 450: (0, 1991), 89: (0, 1990), 451: (0, 2053), 60: (0, 1994), 107: (0, 2029), 442: (0, 1984)}, 2377: {112: (0, 1009)}, 2378: {57: (1, {'@': 504}), 60: (1, {'@': 504}), 126: (1, {'@': 504}), 539: (1, {'@': 504})}, 2379: {144: (0, 2316), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 86: (0, 1062), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 544: (0, 1053), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 545: (0, 1047), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 688: (0, 1073), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 145: (0, 1075), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2380: {60: (0, 124), 146: (0, 148)}, 2381: {77: (0, 17), 689: (0, 2183), 78: (0, 1960), 79: (0, 1973), 194: (0, 2185), 12: (0, 396), 81: (0, 2295), 82: (0, 791), 83: (0, 809), 84: (0, 811), 85: (0, 816), 10: (0, 826), 87: (0, 842), 35: (0, 844), 88: (0, 848), 89: (0, 2384), 90: (0, 853), 91: (0, 863), 511: (0, 2187), 509: (0, 2189), 507: (0, 2193), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 508: (0, 2194), 56: (0, 783), 95: (0, 786), 96: (0, 789), 97: (0, 2370), 98: (0, 793), 19: (0, 800), 13: (0, 802), 32: (0, 807), 99: (0, 812), 100: (0, 817), 20: (0, 822), 102: (0, 823), 103: (0, 825), 105: (0, 830), 65: (0, 834), 86: (0, 2195), 106: (0, 838), 107: (0, 2409), 108: (0, 400), 109: (0, 390), 46: (0, 781), 80: (0, 2414), 510: (0, 2198), 110: (0, 799), 111: (0, 821), 14: (0, 399), 112: (0, 2376), 113: (0, 828), 114: (0, 832), 0: (0, 846), 42: (0, 858), 39: (0, 860), 115: (0, 44), 116: (0, 780), 5: (0, 787), 117: (0, 804), 24: (0, 814), 118: (0, 819), 119: (0, 836), 120: (0, 840), 122: (0, 850), 3: (0, 855), 123: (0, 856), 124: (0, 864)}, 2382: {57: (1, {'@': 506}), 60: (1, {'@': 506}), 126: (1, {'@': 506}), 524: (1, {'@': 506})}, 2383: {115: (0, 44), 77: (0, 17), 108: (0, 400), 489: (0, 2074), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 487: (0, 2082), 46: (0, 781), 488: (0, 2101), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 86: (0, 2102), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2384: {112: (0, 2001), 450: (0, 1991), 89: (0, 1990), 443: (0, 2460), 107: (0, 2029), 442: (0, 1984), 451: (0, 2589)}, 2385: {53: (0, 387), 172: (0, 155), 126: (0, 156), 60: (1, {'@': 1361}), 57: (1, {'@': 1361})}, 2386: {126: (1, {'@': 1634}), 60: (1, {'@': 1634})}, 2387: {146: (0, 144)}, 2388: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 194: (0, 2004), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 86: (0, 2086), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 2389: {146: (0, 141)}, 2390: {690: (0, 1119), 691: (0, 1120), 692: (0, 1121), 693: (0, 1122), 103: (0, 1125), 552: (0, 1126), 694: (0, 1127), 90: (0, 1128), 695: (0, 1130), 114: (0, 1132), 696: (0, 1133), 87: (0, 1134), 697: (0, 1136), 698: (0, 1138), 551: (0, 1141), 106: (0, 1144), 699: (0, 1146), 553: (0, 1149), 96: (0, 1152), 700: (0, 1153), 82: (0, 1156)}, 2391: {60: (0, 136)}, 2392: {57: (1, {'@': 869}), 60: (1, {'@': 869})}, 2393: {501: (0, 1985), 500: (0, 2010), 701: (0, 2017), 528: (0, 2454), 529: (0, 2292), 527: (0, 2231), 60: (1, {'@': 538}), 57: (1, {'@': 538})}, 2394: {184: (0, 1065), 17: (0, 50), 183: (0, 22), 7: (0, 45), 185: (0, 19), 28: (0, 33), 6: (0, 20), 180: (0, 27), 61: (0, 25), 164: (0, 24), 182: (0, 23)}, 2395: {265: (0, 993), 4: (0, 405), 266: (0, 1016), 268: (0, 1462), 267: (0, 2040), 269: (0, 1465), 67: (0, 1913), 166: (0, 1468), 270: (0, 1470), 30: (0, 1920), 162: (0, 1472), 161: (0, 1476), 272: (0, 1483)}, 2396: {17: (0, 50), 7: (0, 45), 184: (0, 1066), 28: (0, 33), 180: (0, 27), 61: (0, 25), 164: (0, 24), 182: (0, 23), 183: (0, 22), 126: (0, 1068), 6: (0, 20), 185: (0, 19), 57: (1, {'@': 902}), 60: (1, {'@': 902})}, 2397: {146: (0, 126)}, 2398: {268: (1, {'@': 1640}), 60: (1, {'@': 1640}), 126: (1, {'@': 1640}), 67: (1, {'@': 1640}), 270: (1, {'@': 1640}), 4: (1, {'@': 1640}), 266: (1, {'@': 1640}), 30: (1, {'@': 1640}), 57: (1, {'@': 1640})}, 2399: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 641: (0, 626), 82: (0, 791), 98: (0, 793), 702: (0, 616), 110: (0, 799), 19: (0, 800), 643: (0, 642), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 642: (0, 644), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 86: (0, 647), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2400: {60: (0, 146)}, 2401: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 194: (0, 761), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 2402: {6: (1, {'@': 1664}), 60: (1, {'@': 1664}), 7: (1, {'@': 1664}), 61: (1, {'@': 1664}), 126: (1, {'@': 1664}), 28: (1, {'@': 1664}), 17: (1, {'@': 1664}), 57: (1, {'@': 1664})}, 2403: {57: (1, {'@': 533}), 60: (1, {'@': 533}), 126: (1, {'@': 533}), 222: (1, {'@': 533}), 220: (1, {'@': 533}), 36: (1, {'@': 533}), 221: (1, {'@': 533}), 223: (1, {'@': 533}), 43: (1, {'@': 533}), 1: (1, {'@': 533}), 2: (1, {'@': 533}), 44: (1, {'@': 533}), 45: (1, {'@': 533}), 47: (1, {'@': 533}), 48: (1, {'@': 533}), 4: (1, {'@': 533}), 49: (1, {'@': 533}), 50: (1, {'@': 533}), 51: (1, {'@': 533}), 6: (1, {'@': 533}), 52: (1, {'@': 533}), 8: (1, {'@': 533}), 7: (1, {'@': 533}), 9: (1, {'@': 533}), 53: (1, {'@': 533}), 11: (1, {'@': 533}), 54: (1, {'@': 533}), 55: (1, {'@': 533}), 15: (1, {'@': 533}), 17: (1, {'@': 533}), 18: (1, {'@': 533}), 58: (1, {'@': 533}), 59: (1, {'@': 533}), 21: (1, {'@': 533}), 22: (1, {'@': 533}), 61: (1, {'@': 533}), 62: (1, {'@': 533}), 23: (1, {'@': 533}), 25: (1, {'@': 533}), 26: (1, {'@': 533}), 63: (1, {'@': 533}), 27: (1, {'@': 533}), 28: (1, {'@': 533}), 29: (1, {'@': 533}), 30: (1, {'@': 533}), 31: (1, {'@': 533}), 33: (1, {'@': 533}), 64: (1, {'@': 533}), 66: (1, {'@': 533}), 67: (1, {'@': 533}), 34: (1, {'@': 533}), 37: (1, {'@': 533}), 68: (1, {'@': 533}), 38: (1, {'@': 533}), 69: (1, {'@': 533}), 70: (1, {'@': 533}), 71: (1, {'@': 533}), 40: (1, {'@': 533}), 72: (1, {'@': 533}), 41: (1, {'@': 533}), 73: (1, {'@': 533}), 74: (1, {'@': 533}), 75: (1, {'@': 533})}, 2404: {77: (0, 17), 78: (0, 1960), 79: (0, 1973), 12: (0, 396), 81: (0, 2295), 82: (0, 791), 83: (0, 809), 84: (0, 811), 85: (0, 816), 10: (0, 826), 87: (0, 842), 35: (0, 844), 88: (0, 848), 89: (0, 2384), 90: (0, 853), 91: (0, 863), 86: (0, 2075), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 56: (0, 783), 95: (0, 786), 96: (0, 789), 97: (0, 2370), 98: (0, 793), 19: (0, 800), 13: (0, 802), 32: (0, 807), 99: (0, 812), 100: (0, 817), 20: (0, 822), 102: (0, 823), 103: (0, 825), 105: (0, 830), 65: (0, 834), 106: (0, 838), 107: (0, 2409), 108: (0, 400), 109: (0, 390), 448: (0, 2092), 46: (0, 781), 80: (0, 2414), 194: (0, 2095), 110: (0, 799), 111: (0, 821), 14: (0, 399), 112: (0, 2376), 113: (0, 828), 114: (0, 832), 0: (0, 846), 42: (0, 858), 39: (0, 860), 115: (0, 44), 703: (0, 2097), 116: (0, 780), 311: (0, 2072), 5: (0, 787), 117: (0, 804), 24: (0, 814), 118: (0, 819), 119: (0, 836), 120: (0, 840), 122: (0, 850), 3: (0, 855), 123: (0, 856), 124: (0, 864)}, 2405: {265: (0, 993), 4: (0, 405), 266: (0, 1016), 268: (0, 1462), 269: (0, 1465), 67: (0, 1913), 166: (0, 1468), 126: (0, 2038), 270: (0, 1470), 30: (0, 1920), 162: (0, 1472), 161: (0, 1476), 267: (0, 2027), 272: (0, 1483), 57: (1, {'@': 613}), 60: (1, {'@': 613})}, 2406: {57: (1, {'@': 1365}), 60: (1, {'@': 1365}), 126: (1, {'@': 1365}), 53: (1, {'@': 1365})}, 2407: {57: (1, {'@': 1368}), 60: (1, {'@': 1368}), 126: (1, {'@': 1368}), 53: (1, {'@': 1368})}, 2408: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 86: (0, 1078), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 194: (0, 1112), 39: (0, 860), 124: (0, 864)}, 2409: {112: (0, 2001), 450: (0, 1991), 89: (0, 1990), 441: (0, 1988), 107: (0, 2029), 442: (0, 1984), 451: (0, 1986)}, 2410: {57: (1, {'@': 1367}), 60: (1, {'@': 1367}), 126: (1, {'@': 1367}), 53: (1, {'@': 1367})}, 2411: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 86: (0, 1084), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 194: (0, 1113), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2412: {60: (0, 209)}, 2413: {57: (1, {'@': 1366}), 60: (1, {'@': 1366}), 126: (1, {'@': 1366}), 53: (1, {'@': 1366})}, 2414: {60: (1, {'@': 1541}), 126: (1, {'@': 1541}), 146: (1, {'@': 1541})}, 2415: {115: (0, 44), 77: (0, 17), 108: (0, 400), 86: (0, 2084), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 194: (0, 2077), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2416: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 86: (0, 1087), 0: (0, 846), 88: (0, 848), 122: (0, 850), 194: (0, 1082), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2417: {60: (0, 167)}, 2418: {60: (1, {'@': 841})}, 2419: {146: (0, 164)}, 2420: {126: (0, 133), 146: (1, {'@': 660})}, 2421: {177: (1, {'@': 600}), 7: (1, {'@': 600}), 22: (1, {'@': 600}), 60: (1, {'@': 600}), 126: (1, {'@': 600}), 48: (1, {'@': 600}), 72: (1, {'@': 600}), 178: (1, {'@': 600}), 179: (1, {'@': 600}), 49: (1, {'@': 600}), 57: (1, {'@': 600})}, 2422: {146: (1, {'@': 664}), 126: (1, {'@': 664})}, 2423: {146: (0, 150)}, 2424: {80: (0, 2414), 81: (0, 2295), 107: (0, 2409), 194: (0, 743), 89: (0, 2384), 112: (0, 2376), 97: (0, 2370)}, 2425: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 89: (0, 2384), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 194: (0, 1079), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 86: (0, 1158), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2426: {126: (0, 142), 146: (1, {'@': 661})}, 2427: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 405: (0, 1818), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 403: (0, 193), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 314: (0, 331), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 86: (0, 1116), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 555: (0, 1160), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 554: (0, 1163), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2428: {60: (0, 1022)}, 2429: {146: (0, 169)}, 2430: {60: (0, 166)}, 2431: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 86: (0, 417), 79: (0, 1973), 116: (0, 780), 194: (0, 420), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2432: {499: (0, 189), 146: (0, 211), 126: (0, 191), 60: (1, {'@': 719})}, 2433: {146: (1, {'@': 1564})}, 2434: {60: (1, {'@': 1542}), 126: (1, {'@': 1542}), 146: (1, {'@': 1542})}, 2435: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 86: (0, 1210), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 194: (0, 1206), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2436: {60: (0, 162)}, 2437: {86: (0, 1172), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 194: (0, 1180), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2438: {146: (0, 174)}, 2439: {192: (0, 2520), 193: (0, 53)}, 2440: {57: (1, {'@': 799}), 60: (1, {'@': 799})}, 2441: {146: (0, 182)}, 2442: {60: (0, 2582)}, 2443: {60: (0, 171)}, 2444: {60: (1, {'@': 1645}), 126: (1, {'@': 1645}), 222: (1, {'@': 1645}), 220: (1, {'@': 1645}), 36: (1, {'@': 1645}), 221: (1, {'@': 1645}), 223: (1, {'@': 1645}), 57: (1, {'@': 1645})}, 2445: {57: (1, {'@': 801}), 60: (1, {'@': 801})}, 2446: {57: (1, {'@': 805}), 60: (1, {'@': 805})}, 2447: {60: (1, {'@': 1648}), 126: (1, {'@': 1648}), 222: (1, {'@': 1648}), 220: (1, {'@': 1648}), 36: (1, {'@': 1648}), 221: (1, {'@': 1648}), 223: (1, {'@': 1648}), 57: (1, {'@': 1648})}, 2448: {197: (0, 870), 220: (0, 869), 221: (0, 872), 36: (0, 15), 222: (0, 874), 223: (0, 876), 229: (0, 889), 227: (0, 885), 228: (0, 887), 226: (0, 883), 225: (0, 185)}, 2449: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 194: (0, 2461), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 86: (0, 446), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 2450: {77: (0, 17), 78: (0, 1960), 79: (0, 1973), 434: (0, 1214), 12: (0, 396), 436: (0, 1217), 81: (0, 2295), 82: (0, 791), 83: (0, 809), 84: (0, 811), 85: (0, 816), 10: (0, 826), 87: (0, 842), 35: (0, 844), 256: (0, 1219), 88: (0, 848), 89: (0, 2384), 90: (0, 853), 91: (0, 863), 92: (0, 1944), 255: (0, 1221), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 56: (0, 783), 95: (0, 786), 194: (0, 1223), 96: (0, 789), 97: (0, 2370), 98: (0, 793), 19: (0, 800), 13: (0, 802), 32: (0, 807), 99: (0, 812), 100: (0, 817), 20: (0, 822), 102: (0, 823), 103: (0, 825), 438: (0, 1230), 105: (0, 830), 65: (0, 834), 106: (0, 838), 107: (0, 2409), 108: (0, 400), 109: (0, 390), 46: (0, 781), 80: (0, 2414), 704: (0, 1232), 564: (0, 1235), 428: (0, 1240), 432: (0, 1242), 110: (0, 799), 562: (0, 1245), 563: (0, 1249), 111: (0, 821), 14: (0, 399), 112: (0, 2376), 113: (0, 828), 114: (0, 832), 0: (0, 846), 42: (0, 858), 39: (0, 860), 115: (0, 44), 116: (0, 780), 439: (0, 1253), 5: (0, 787), 117: (0, 804), 24: (0, 814), 118: (0, 819), 119: (0, 836), 120: (0, 840), 122: (0, 850), 3: (0, 855), 86: (0, 1257), 123: (0, 856), 124: (0, 864)}, 2451: {60: (1, {'@': 1295})}, 2452: {128: (0, 14), 129: (0, 12), 130: (0, 11), 131: (0, 10), 132: (0, 8), 133: (0, 4), 134: (0, 13), 136: (0, 9), 137: (0, 5), 138: (0, 6), 139: (0, 18), 141: (0, 49), 142: (0, 46), 143: (0, 26), 140: (0, 1181), 126: (0, 1185), 57: (1, {'@': 673}), 60: (1, {'@': 673})}, 2453: {146: (0, 180)}, 2454: {500: (1, {'@': 542}), 60: (1, {'@': 542}), 501: (1, {'@': 542}), 126: (1, {'@': 542}), 57: (1, {'@': 542})}, 2455: {260: (0, 997), 263: (0, 1013), 261: (0, 2595), 262: (0, 2523)}, 2456: {60: (0, 154)}, 2457: {133: (1, {'@': 1650}), 130: (1, {'@': 1650}), 141: (1, {'@': 1650}), 60: (1, {'@': 1650}), 129: (1, {'@': 1650}), 126: (1, {'@': 1650}), 134: (1, {'@': 1650}), 57: (1, {'@': 1650}), 132: (1, {'@': 1650}), 139: (1, {'@': 1650})}, 2458: {128: (0, 14), 129: (0, 12), 130: (0, 11), 131: (0, 10), 132: (0, 8), 133: (0, 4), 134: (0, 13), 140: (0, 1167), 136: (0, 9), 137: (0, 5), 138: (0, 6), 139: (0, 18), 141: (0, 49), 142: (0, 46), 143: (0, 26)}, 2459: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 86: (0, 1974), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 194: (0, 2056), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 2460: {112: (1, {'@': 1707}), 89: (1, {'@': 1707}), 97: (1, {'@': 1707}), 107: (1, {'@': 1707}), 126: (1, {'@': 1707}), 146: (1, {'@': 1707}), 60: (1, {'@': 1707})}, 2461: {60: (0, 1522)}, 2462: {43: (1, {'@': 453}), 1: (1, {'@': 453}), 2: (1, {'@': 453}), 44: (1, {'@': 453}), 45: (1, {'@': 453}), 47: (1, {'@': 453}), 48: (1, {'@': 453}), 4: (1, {'@': 453}), 49: (1, {'@': 453}), 50: (1, {'@': 453}), 51: (1, {'@': 453}), 6: (1, {'@': 453}), 52: (1, {'@': 453}), 8: (1, {'@': 453}), 7: (1, {'@': 453}), 9: (1, {'@': 453}), 53: (1, {'@': 453}), 11: (1, {'@': 453}), 54: (1, {'@': 453}), 55: (1, {'@': 453}), 15: (1, {'@': 453}), 17: (1, {'@': 453}), 57: (1, {'@': 453}), 18: (1, {'@': 453}), 58: (1, {'@': 453}), 59: (1, {'@': 453}), 21: (1, {'@': 453}), 22: (1, {'@': 453}), 60: (1, {'@': 453}), 61: (1, {'@': 453}), 126: (1, {'@': 453}), 62: (1, {'@': 453}), 23: (1, {'@': 453}), 25: (1, {'@': 453}), 26: (1, {'@': 453}), 63: (1, {'@': 453}), 27: (1, {'@': 453}), 28: (1, {'@': 453}), 29: (1, {'@': 453}), 30: (1, {'@': 453}), 31: (1, {'@': 453}), 33: (1, {'@': 453}), 64: (1, {'@': 453}), 66: (1, {'@': 453}), 67: (1, {'@': 453}), 34: (1, {'@': 453}), 36: (1, {'@': 453}), 37: (1, {'@': 453}), 68: (1, {'@': 453}), 38: (1, {'@': 453}), 69: (1, {'@': 453}), 70: (1, {'@': 453}), 71: (1, {'@': 453}), 40: (1, {'@': 453}), 72: (1, {'@': 453}), 41: (1, {'@': 453}), 73: (1, {'@': 453}), 74: (1, {'@': 453}), 75: (1, {'@': 453})}, 2463: {230: (1, {'@': 1653}), 60: (1, {'@': 1653}), 235: (1, {'@': 1653}), 240: (1, {'@': 1653}), 126: (1, {'@': 1653}), 231: (1, {'@': 1653}), 234: (1, {'@': 1653}), 57: (1, {'@': 1653}), 241: (1, {'@': 1653}), 243: (1, {'@': 1653})}, 2464: {43: (1, {'@': 1612}), 0: (1, {'@': 1612}), 1: (1, {'@': 1612}), 2: (1, {'@': 1612}), 3: (1, {'@': 1612}), 44: (1, {'@': 1612}), 45: (1, {'@': 1612}), 46: (1, {'@': 1612}), 47: (1, {'@': 1612}), 48: (1, {'@': 1612}), 4: (1, {'@': 1612}), 49: (1, {'@': 1612}), 50: (1, {'@': 1612}), 51: (1, {'@': 1612}), 5: (1, {'@': 1612}), 6: (1, {'@': 1612}), 52: (1, {'@': 1612}), 8: (1, {'@': 1612}), 7: (1, {'@': 1612}), 9: (1, {'@': 1612}), 53: (1, {'@': 1612}), 10: (1, {'@': 1612}), 11: (1, {'@': 1612}), 35: (1, {'@': 1612}), 54: (1, {'@': 1612}), 12: (1, {'@': 1612}), 42: (1, {'@': 1612}), 13: (1, {'@': 1612}), 14: (1, {'@': 1612}), 55: (1, {'@': 1612}), 15: (1, {'@': 1612}), 16: (1, {'@': 1612}), 56: (1, {'@': 1612}), 18: (1, {'@': 1612}), 17: (1, {'@': 1612}), 57: (1, {'@': 1612}), 19: (1, {'@': 1612}), 20: (1, {'@': 1612}), 58: (1, {'@': 1612}), 59: (1, {'@': 1612}), 21: (1, {'@': 1612}), 22: (1, {'@': 1612}), 60: (1, {'@': 1612}), 61: (1, {'@': 1612}), 62: (1, {'@': 1612}), 23: (1, {'@': 1612}), 24: (1, {'@': 1612}), 25: (1, {'@': 1612}), 26: (1, {'@': 1612}), 63: (1, {'@': 1612}), 27: (1, {'@': 1612}), 28: (1, {'@': 1612}), 29: (1, {'@': 1612}), 30: (1, {'@': 1612}), 31: (1, {'@': 1612}), 32: (1, {'@': 1612}), 33: (1, {'@': 1612}), 64: (1, {'@': 1612}), 65: (1, {'@': 1612}), 66: (1, {'@': 1612}), 67: (1, {'@': 1612}), 34: (1, {'@': 1612}), 36: (1, {'@': 1612}), 37: (1, {'@': 1612}), 68: (1, {'@': 1612}), 38: (1, {'@': 1612}), 69: (1, {'@': 1612}), 70: (1, {'@': 1612}), 71: (1, {'@': 1612}), 40: (1, {'@': 1612}), 72: (1, {'@': 1612}), 39: (1, {'@': 1612}), 41: (1, {'@': 1612}), 73: (1, {'@': 1612}), 74: (1, {'@': 1612}), 75: (1, {'@': 1612})}, 2465: {296: (0, 2462), 58: (0, 1666), 48: (0, 1843), 29: (0, 1870), 63: (0, 2218), 64: (0, 1537), 53: (0, 387), 41: (0, 372), 70: (0, 1727), 50: (0, 1792), 26: (0, 1797), 484: (0, 2472), 8: (0, 1510), 38: (0, 1811), 183: (0, 2473), 49: (0, 335), 295: (0, 2475), 43: (0, 1548), 61: (0, 25), 165: (0, 2477), 1: (0, 1793), 69: (0, 1760), 67: (0, 1913), 45: (0, 1833), 30: (0, 1920), 51: (0, 1695), 71: (0, 2263), 206: (0, 2479), 52: (0, 1498), 6: (0, 20), 44: (0, 358), 203: (0, 2481), 280: (0, 2482), 40: (0, 1756), 15: (0, 1909), 33: (0, 383), 213: (0, 2484), 18: (0, 1581), 7: (0, 45), 445: (0, 2485), 66: (0, 1679), 21: (0, 366), 2: (0, 2225), 55: (0, 2229), 217: (0, 2487), 166: (0, 2489), 126: (0, 2060), 59: (0, 363), 182: (0, 2490), 212: (0, 2492), 34: (0, 1589), 284: (0, 2496), 28: (0, 33), 36: (0, 15), 54: (0, 1598), 164: (0, 2498), 72: (0, 1882), 286: (0, 2500), 31: (0, 1901), 17: (0, 50), 37: (0, 1828), 211: (0, 2501), 485: (0, 2063), 73: (0, 1763), 23: (0, 327), 22: (0, 389), 68: (0, 1724), 198: (0, 2505), 705: (0, 2064), 210: (0, 2507), 74: (0, 1616), 483: (0, 2508), 309: (0, 2510), 27: (0, 408), 392: (0, 2511), 180: (0, 2513), 292: (0, 2515), 398: (0, 2517), 287: (0, 2518), 4: (0, 405), 200: (0, 2519), 11: (0, 84), 162: (0, 2522), 47: (0, 1820), 172: (0, 2524), 197: (0, 2526), 410: (0, 2528), 202: (0, 2530), 9: (0, 1906), 290: (0, 2532), 204: (0, 2534), 205: (0, 2537), 167: (0, 2539), 215: (0, 2541), 163: (0, 2543), 207: (0, 2545), 62: (0, 367), 185: (0, 2546), 170: (0, 2550), 75: (0, 341), 168: (0, 2551), 395: (0, 2553), 396: (0, 2554), 444: (0, 2556), 161: (0, 2558), 208: (0, 2560), 481: (0, 2561), 173: (0, 2564), 283: (0, 2567), 169: (0, 2568), 25: (0, 1783), 479: (0, 2571), 482: (0, 2572), 201: (0, 2575), 281: (0, 2577), 57: (1, {'@': 438}), 60: (1, {'@': 438})}, 2466: {230: (1, {'@': 1656}), 60: (1, {'@': 1656}), 235: (1, {'@': 1656}), 240: (1, {'@': 1656}), 126: (1, {'@': 1656}), 231: (1, {'@': 1656}), 234: (1, {'@': 1656}), 57: (1, {'@': 1656}), 241: (1, {'@': 1656}), 243: (1, {'@': 1656})}, 2467: {230: (0, 891), 232: (0, 198), 231: (0, 893), 234: (0, 900), 235: (0, 901), 236: (0, 903), 237: (0, 905), 238: (0, 907), 239: (0, 910), 240: (0, 912), 241: (0, 914), 242: (0, 916), 243: (0, 917), 244: (0, 919), 245: (0, 921)}, 2468: {107: (0, 2409), 112: (0, 2376), 81: (0, 2295), 80: (0, 2414), 194: (0, 1223), 97: (0, 2370), 89: (0, 2384), 428: (0, 1342)}, 2469: {146: (0, 980), 60: (0, 976)}, 2470: {685: (0, 1261), 618: (0, 1265), 687: (0, 1269), 619: (0, 1273)}, 2471: {146: (0, 332)}, 2472: {43: (1, {'@': 463}), 1: (1, {'@': 463}), 2: (1, {'@': 463}), 44: (1, {'@': 463}), 45: (1, {'@': 463}), 47: (1, {'@': 463}), 48: (1, {'@': 463}), 4: (1, {'@': 463}), 49: (1, {'@': 463}), 50: (1, {'@': 463}), 51: (1, {'@': 463}), 6: (1, {'@': 463}), 52: (1, {'@': 463}), 8: (1, {'@': 463}), 7: (1, {'@': 463}), 9: (1, {'@': 463}), 53: (1, {'@': 463}), 11: (1, {'@': 463}), 54: (1, {'@': 463}), 55: (1, {'@': 463}), 15: (1, {'@': 463}), 17: (1, {'@': 463}), 57: (1, {'@': 463}), 18: (1, {'@': 463}), 58: (1, {'@': 463}), 59: (1, {'@': 463}), 21: (1, {'@': 463}), 22: (1, {'@': 463}), 60: (1, {'@': 463}), 61: (1, {'@': 463}), 126: (1, {'@': 463}), 62: (1, {'@': 463}), 23: (1, {'@': 463}), 25: (1, {'@': 463}), 26: (1, {'@': 463}), 63: (1, {'@': 463}), 27: (1, {'@': 463}), 28: (1, {'@': 463}), 29: (1, {'@': 463}), 30: (1, {'@': 463}), 31: (1, {'@': 463}), 33: (1, {'@': 463}), 64: (1, {'@': 463}), 66: (1, {'@': 463}), 67: (1, {'@': 463}), 34: (1, {'@': 463}), 36: (1, {'@': 463}), 37: (1, {'@': 463}), 68: (1, {'@': 463}), 38: (1, {'@': 463}), 69: (1, {'@': 463}), 70: (1, {'@': 463}), 71: (1, {'@': 463}), 40: (1, {'@': 463}), 72: (1, {'@': 463}), 41: (1, {'@': 463}), 73: (1, {'@': 463}), 74: (1, {'@': 463}), 75: (1, {'@': 463})}, 2473: {43: (1, {'@': 442}), 1: (1, {'@': 442}), 2: (1, {'@': 442}), 44: (1, {'@': 442}), 45: (1, {'@': 442}), 47: (1, {'@': 442}), 48: (1, {'@': 442}), 4: (1, {'@': 442}), 49: (1, {'@': 442}), 50: (1, {'@': 442}), 51: (1, {'@': 442}), 6: (1, {'@': 442}), 52: (1, {'@': 442}), 8: (1, {'@': 442}), 7: (1, {'@': 442}), 9: (1, {'@': 442}), 53: (1, {'@': 442}), 11: (1, {'@': 442}), 54: (1, {'@': 442}), 55: (1, {'@': 442}), 15: (1, {'@': 442}), 17: (1, {'@': 442}), 57: (1, {'@': 442}), 18: (1, {'@': 442}), 58: (1, {'@': 442}), 59: (1, {'@': 442}), 21: (1, {'@': 442}), 22: (1, {'@': 442}), 60: (1, {'@': 442}), 61: (1, {'@': 442}), 126: (1, {'@': 442}), 62: (1, {'@': 442}), 23: (1, {'@': 442}), 25: (1, {'@': 442}), 26: (1, {'@': 442}), 63: (1, {'@': 442}), 27: (1, {'@': 442}), 28: (1, {'@': 442}), 29: (1, {'@': 442}), 30: (1, {'@': 442}), 31: (1, {'@': 442}), 33: (1, {'@': 442}), 64: (1, {'@': 442}), 66: (1, {'@': 442}), 67: (1, {'@': 442}), 34: (1, {'@': 442}), 36: (1, {'@': 442}), 37: (1, {'@': 442}), 68: (1, {'@': 442}), 38: (1, {'@': 442}), 69: (1, {'@': 442}), 70: (1, {'@': 442}), 71: (1, {'@': 442}), 40: (1, {'@': 442}), 72: (1, {'@': 442}), 41: (1, {'@': 442}), 73: (1, {'@': 442}), 74: (1, {'@': 442}), 75: (1, {'@': 442})}, 2474: {146: (0, 854)}, 2475: {43: (1, {'@': 452}), 1: (1, {'@': 452}), 2: (1, {'@': 452}), 44: (1, {'@': 452}), 45: (1, {'@': 452}), 47: (1, {'@': 452}), 48: (1, {'@': 452}), 4: (1, {'@': 452}), 49: (1, {'@': 452}), 50: (1, {'@': 452}), 51: (1, {'@': 452}), 6: (1, {'@': 452}), 52: (1, {'@': 452}), 8: (1, {'@': 452}), 7: (1, {'@': 452}), 9: (1, {'@': 452}), 53: (1, {'@': 452}), 11: (1, {'@': 452}), 54: (1, {'@': 452}), 55: (1, {'@': 452}), 15: (1, {'@': 452}), 17: (1, {'@': 452}), 57: (1, {'@': 452}), 18: (1, {'@': 452}), 58: (1, {'@': 452}), 59: (1, {'@': 452}), 21: (1, {'@': 452}), 22: (1, {'@': 452}), 60: (1, {'@': 452}), 61: (1, {'@': 452}), 126: (1, {'@': 452}), 62: (1, {'@': 452}), 23: (1, {'@': 452}), 25: (1, {'@': 452}), 26: (1, {'@': 452}), 63: (1, {'@': 452}), 27: (1, {'@': 452}), 28: (1, {'@': 452}), 29: (1, {'@': 452}), 30: (1, {'@': 452}), 31: (1, {'@': 452}), 33: (1, {'@': 452}), 64: (1, {'@': 452}), 66: (1, {'@': 452}), 67: (1, {'@': 452}), 34: (1, {'@': 452}), 36: (1, {'@': 452}), 37: (1, {'@': 452}), 68: (1, {'@': 452}), 38: (1, {'@': 452}), 69: (1, {'@': 452}), 70: (1, {'@': 452}), 71: (1, {'@': 452}), 40: (1, {'@': 452}), 72: (1, {'@': 452}), 41: (1, {'@': 452}), 73: (1, {'@': 452}), 74: (1, {'@': 452}), 75: (1, {'@': 452})}, 2476: {60: (0, 835)}, 2477: {43: (1, {'@': 448}), 1: (1, {'@': 448}), 2: (1, {'@': 448}), 44: (1, {'@': 448}), 45: (1, {'@': 448}), 47: (1, {'@': 448}), 48: (1, {'@': 448}), 4: (1, {'@': 448}), 49: (1, {'@': 448}), 50: (1, {'@': 448}), 51: (1, {'@': 448}), 6: (1, {'@': 448}), 52: (1, {'@': 448}), 8: (1, {'@': 448}), 7: (1, {'@': 448}), 9: (1, {'@': 448}), 53: (1, {'@': 448}), 11: (1, {'@': 448}), 54: (1, {'@': 448}), 55: (1, {'@': 448}), 15: (1, {'@': 448}), 17: (1, {'@': 448}), 57: (1, {'@': 448}), 18: (1, {'@': 448}), 58: (1, {'@': 448}), 59: (1, {'@': 448}), 21: (1, {'@': 448}), 22: (1, {'@': 448}), 60: (1, {'@': 448}), 61: (1, {'@': 448}), 126: (1, {'@': 448}), 62: (1, {'@': 448}), 23: (1, {'@': 448}), 25: (1, {'@': 448}), 26: (1, {'@': 448}), 63: (1, {'@': 448}), 27: (1, {'@': 448}), 28: (1, {'@': 448}), 29: (1, {'@': 448}), 30: (1, {'@': 448}), 31: (1, {'@': 448}), 33: (1, {'@': 448}), 64: (1, {'@': 448}), 66: (1, {'@': 448}), 67: (1, {'@': 448}), 34: (1, {'@': 448}), 36: (1, {'@': 448}), 37: (1, {'@': 448}), 68: (1, {'@': 448}), 38: (1, {'@': 448}), 69: (1, {'@': 448}), 70: (1, {'@': 448}), 71: (1, {'@': 448}), 40: (1, {'@': 448}), 72: (1, {'@': 448}), 41: (1, {'@': 448}), 73: (1, {'@': 448}), 74: (1, {'@': 448}), 75: (1, {'@': 448})}, 2478: {144: (0, 2316), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 145: (0, 187), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 86: (0, 1290), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2479: {43: (1, {'@': 471}), 1: (1, {'@': 471}), 2: (1, {'@': 471}), 44: (1, {'@': 471}), 45: (1, {'@': 471}), 47: (1, {'@': 471}), 48: (1, {'@': 471}), 4: (1, {'@': 471}), 49: (1, {'@': 471}), 50: (1, {'@': 471}), 51: (1, {'@': 471}), 6: (1, {'@': 471}), 52: (1, {'@': 471}), 8: (1, {'@': 471}), 7: (1, {'@': 471}), 9: (1, {'@': 471}), 53: (1, {'@': 471}), 11: (1, {'@': 471}), 54: (1, {'@': 471}), 55: (1, {'@': 471}), 15: (1, {'@': 471}), 17: (1, {'@': 471}), 57: (1, {'@': 471}), 18: (1, {'@': 471}), 58: (1, {'@': 471}), 59: (1, {'@': 471}), 21: (1, {'@': 471}), 22: (1, {'@': 471}), 60: (1, {'@': 471}), 61: (1, {'@': 471}), 126: (1, {'@': 471}), 62: (1, {'@': 471}), 23: (1, {'@': 471}), 25: (1, {'@': 471}), 26: (1, {'@': 471}), 63: (1, {'@': 471}), 27: (1, {'@': 471}), 28: (1, {'@': 471}), 29: (1, {'@': 471}), 30: (1, {'@': 471}), 31: (1, {'@': 471}), 33: (1, {'@': 471}), 64: (1, {'@': 471}), 66: (1, {'@': 471}), 67: (1, {'@': 471}), 34: (1, {'@': 471}), 36: (1, {'@': 471}), 37: (1, {'@': 471}), 68: (1, {'@': 471}), 38: (1, {'@': 471}), 69: (1, {'@': 471}), 70: (1, {'@': 471}), 71: (1, {'@': 471}), 40: (1, {'@': 471}), 72: (1, {'@': 471}), 41: (1, {'@': 471}), 73: (1, {'@': 471}), 74: (1, {'@': 471}), 75: (1, {'@': 471})}, 2480: {60: (0, 204)}, 2481: {43: (1, {'@': 487}), 1: (1, {'@': 487}), 2: (1, {'@': 487}), 44: (1, {'@': 487}), 45: (1, {'@': 487}), 47: (1, {'@': 487}), 48: (1, {'@': 487}), 4: (1, {'@': 487}), 49: (1, {'@': 487}), 50: (1, {'@': 487}), 51: (1, {'@': 487}), 6: (1, {'@': 487}), 52: (1, {'@': 487}), 8: (1, {'@': 487}), 7: (1, {'@': 487}), 9: (1, {'@': 487}), 53: (1, {'@': 487}), 11: (1, {'@': 487}), 54: (1, {'@': 487}), 55: (1, {'@': 487}), 15: (1, {'@': 487}), 17: (1, {'@': 487}), 57: (1, {'@': 487}), 18: (1, {'@': 487}), 58: (1, {'@': 487}), 59: (1, {'@': 487}), 21: (1, {'@': 487}), 22: (1, {'@': 487}), 60: (1, {'@': 487}), 61: (1, {'@': 487}), 126: (1, {'@': 487}), 62: (1, {'@': 487}), 23: (1, {'@': 487}), 25: (1, {'@': 487}), 26: (1, {'@': 487}), 63: (1, {'@': 487}), 27: (1, {'@': 487}), 28: (1, {'@': 487}), 29: (1, {'@': 487}), 30: (1, {'@': 487}), 31: (1, {'@': 487}), 33: (1, {'@': 487}), 64: (1, {'@': 487}), 66: (1, {'@': 487}), 67: (1, {'@': 487}), 34: (1, {'@': 487}), 36: (1, {'@': 487}), 37: (1, {'@': 487}), 68: (1, {'@': 487}), 38: (1, {'@': 487}), 69: (1, {'@': 487}), 70: (1, {'@': 487}), 71: (1, {'@': 487}), 40: (1, {'@': 487}), 72: (1, {'@': 487}), 41: (1, {'@': 487}), 73: (1, {'@': 487}), 74: (1, {'@': 487}), 75: (1, {'@': 487})}, 2482: {43: (1, {'@': 478}), 1: (1, {'@': 478}), 2: (1, {'@': 478}), 44: (1, {'@': 478}), 45: (1, {'@': 478}), 47: (1, {'@': 478}), 48: (1, {'@': 478}), 4: (1, {'@': 478}), 49: (1, {'@': 478}), 50: (1, {'@': 478}), 51: (1, {'@': 478}), 6: (1, {'@': 478}), 52: (1, {'@': 478}), 8: (1, {'@': 478}), 7: (1, {'@': 478}), 9: (1, {'@': 478}), 53: (1, {'@': 478}), 11: (1, {'@': 478}), 54: (1, {'@': 478}), 55: (1, {'@': 478}), 15: (1, {'@': 478}), 17: (1, {'@': 478}), 57: (1, {'@': 478}), 18: (1, {'@': 478}), 58: (1, {'@': 478}), 59: (1, {'@': 478}), 21: (1, {'@': 478}), 22: (1, {'@': 478}), 60: (1, {'@': 478}), 61: (1, {'@': 478}), 126: (1, {'@': 478}), 62: (1, {'@': 478}), 23: (1, {'@': 478}), 25: (1, {'@': 478}), 26: (1, {'@': 478}), 63: (1, {'@': 478}), 27: (1, {'@': 478}), 28: (1, {'@': 478}), 29: (1, {'@': 478}), 30: (1, {'@': 478}), 31: (1, {'@': 478}), 33: (1, {'@': 478}), 64: (1, {'@': 478}), 66: (1, {'@': 478}), 67: (1, {'@': 478}), 34: (1, {'@': 478}), 36: (1, {'@': 478}), 37: (1, {'@': 478}), 68: (1, {'@': 478}), 38: (1, {'@': 478}), 69: (1, {'@': 478}), 70: (1, {'@': 478}), 71: (1, {'@': 478}), 40: (1, {'@': 478}), 72: (1, {'@': 478}), 41: (1, {'@': 478}), 73: (1, {'@': 478}), 74: (1, {'@': 478}), 75: (1, {'@': 478})}, 2483: {146: (0, 206)}, 2484: {43: (1, {'@': 472}), 1: (1, {'@': 472}), 2: (1, {'@': 472}), 44: (1, {'@': 472}), 45: (1, {'@': 472}), 47: (1, {'@': 472}), 48: (1, {'@': 472}), 4: (1, {'@': 472}), 49: (1, {'@': 472}), 50: (1, {'@': 472}), 51: (1, {'@': 472}), 6: (1, {'@': 472}), 52: (1, {'@': 472}), 8: (1, {'@': 472}), 7: (1, {'@': 472}), 9: (1, {'@': 472}), 53: (1, {'@': 472}), 11: (1, {'@': 472}), 54: (1, {'@': 472}), 55: (1, {'@': 472}), 15: (1, {'@': 472}), 17: (1, {'@': 472}), 57: (1, {'@': 472}), 18: (1, {'@': 472}), 58: (1, {'@': 472}), 59: (1, {'@': 472}), 21: (1, {'@': 472}), 22: (1, {'@': 472}), 60: (1, {'@': 472}), 61: (1, {'@': 472}), 126: (1, {'@': 472}), 62: (1, {'@': 472}), 23: (1, {'@': 472}), 25: (1, {'@': 472}), 26: (1, {'@': 472}), 63: (1, {'@': 472}), 27: (1, {'@': 472}), 28: (1, {'@': 472}), 29: (1, {'@': 472}), 30: (1, {'@': 472}), 31: (1, {'@': 472}), 33: (1, {'@': 472}), 64: (1, {'@': 472}), 66: (1, {'@': 472}), 67: (1, {'@': 472}), 34: (1, {'@': 472}), 36: (1, {'@': 472}), 37: (1, {'@': 472}), 68: (1, {'@': 472}), 38: (1, {'@': 472}), 69: (1, {'@': 472}), 70: (1, {'@': 472}), 71: (1, {'@': 472}), 40: (1, {'@': 472}), 72: (1, {'@': 472}), 41: (1, {'@': 472}), 73: (1, {'@': 472}), 74: (1, {'@': 472}), 75: (1, {'@': 472})}, 2485: {43: (1, {'@': 494}), 1: (1, {'@': 494}), 2: (1, {'@': 494}), 44: (1, {'@': 494}), 45: (1, {'@': 494}), 47: (1, {'@': 494}), 48: (1, {'@': 494}), 4: (1, {'@': 494}), 49: (1, {'@': 494}), 50: (1, {'@': 494}), 51: (1, {'@': 494}), 6: (1, {'@': 494}), 52: (1, {'@': 494}), 8: (1, {'@': 494}), 7: (1, {'@': 494}), 9: (1, {'@': 494}), 53: (1, {'@': 494}), 11: (1, {'@': 494}), 54: (1, {'@': 494}), 55: (1, {'@': 494}), 15: (1, {'@': 494}), 17: (1, {'@': 494}), 57: (1, {'@': 494}), 18: (1, {'@': 494}), 58: (1, {'@': 494}), 59: (1, {'@': 494}), 21: (1, {'@': 494}), 22: (1, {'@': 494}), 60: (1, {'@': 494}), 61: (1, {'@': 494}), 126: (1, {'@': 494}), 62: (1, {'@': 494}), 23: (1, {'@': 494}), 25: (1, {'@': 494}), 26: (1, {'@': 494}), 63: (1, {'@': 494}), 27: (1, {'@': 494}), 28: (1, {'@': 494}), 29: (1, {'@': 494}), 30: (1, {'@': 494}), 31: (1, {'@': 494}), 33: (1, {'@': 494}), 64: (1, {'@': 494}), 66: (1, {'@': 494}), 67: (1, {'@': 494}), 34: (1, {'@': 494}), 36: (1, {'@': 494}), 37: (1, {'@': 494}), 68: (1, {'@': 494}), 38: (1, {'@': 494}), 69: (1, {'@': 494}), 70: (1, {'@': 494}), 71: (1, {'@': 494}), 40: (1, {'@': 494}), 72: (1, {'@': 494}), 41: (1, {'@': 494}), 73: (1, {'@': 494}), 74: (1, {'@': 494}), 75: (1, {'@': 494})}, 2486: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 669: (0, 2104), 116: (0, 780), 46: (0, 781), 668: (0, 2106), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 124: (0, 864), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 670: (0, 2107), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 86: (0, 2108)}, 2487: {43: (1, {'@': 467}), 1: (1, {'@': 467}), 2: (1, {'@': 467}), 44: (1, {'@': 467}), 45: (1, {'@': 467}), 47: (1, {'@': 467}), 48: (1, {'@': 467}), 4: (1, {'@': 467}), 49: (1, {'@': 467}), 50: (1, {'@': 467}), 51: (1, {'@': 467}), 6: (1, {'@': 467}), 52: (1, {'@': 467}), 8: (1, {'@': 467}), 7: (1, {'@': 467}), 9: (1, {'@': 467}), 53: (1, {'@': 467}), 11: (1, {'@': 467}), 54: (1, {'@': 467}), 55: (1, {'@': 467}), 15: (1, {'@': 467}), 17: (1, {'@': 467}), 57: (1, {'@': 467}), 18: (1, {'@': 467}), 58: (1, {'@': 467}), 59: (1, {'@': 467}), 21: (1, {'@': 467}), 22: (1, {'@': 467}), 60: (1, {'@': 467}), 61: (1, {'@': 467}), 126: (1, {'@': 467}), 62: (1, {'@': 467}), 23: (1, {'@': 467}), 25: (1, {'@': 467}), 26: (1, {'@': 467}), 63: (1, {'@': 467}), 27: (1, {'@': 467}), 28: (1, {'@': 467}), 29: (1, {'@': 467}), 30: (1, {'@': 467}), 31: (1, {'@': 467}), 33: (1, {'@': 467}), 64: (1, {'@': 467}), 66: (1, {'@': 467}), 67: (1, {'@': 467}), 34: (1, {'@': 467}), 36: (1, {'@': 467}), 37: (1, {'@': 467}), 68: (1, {'@': 467}), 38: (1, {'@': 467}), 69: (1, {'@': 467}), 70: (1, {'@': 467}), 71: (1, {'@': 467}), 40: (1, {'@': 467}), 72: (1, {'@': 467}), 41: (1, {'@': 467}), 73: (1, {'@': 467}), 74: (1, {'@': 467}), 75: (1, {'@': 467})}, 2488: {57: (1, {'@': 1175}), 60: (1, {'@': 1175}), 43: (1, {'@': 1175}), 1: (1, {'@': 1175}), 2: (1, {'@': 1175}), 44: (1, {'@': 1175}), 45: (1, {'@': 1175}), 47: (1, {'@': 1175}), 48: (1, {'@': 1175}), 4: (1, {'@': 1175}), 49: (1, {'@': 1175}), 50: (1, {'@': 1175}), 51: (1, {'@': 1175}), 6: (1, {'@': 1175}), 52: (1, {'@': 1175}), 8: (1, {'@': 1175}), 7: (1, {'@': 1175}), 9: (1, {'@': 1175}), 53: (1, {'@': 1175}), 11: (1, {'@': 1175}), 54: (1, {'@': 1175}), 55: (1, {'@': 1175}), 15: (1, {'@': 1175}), 17: (1, {'@': 1175}), 18: (1, {'@': 1175}), 58: (1, {'@': 1175}), 59: (1, {'@': 1175}), 21: (1, {'@': 1175}), 22: (1, {'@': 1175}), 61: (1, {'@': 1175}), 126: (1, {'@': 1175}), 62: (1, {'@': 1175}), 23: (1, {'@': 1175}), 25: (1, {'@': 1175}), 26: (1, {'@': 1175}), 63: (1, {'@': 1175}), 27: (1, {'@': 1175}), 28: (1, {'@': 1175}), 29: (1, {'@': 1175}), 30: (1, {'@': 1175}), 31: (1, {'@': 1175}), 33: (1, {'@': 1175}), 64: (1, {'@': 1175}), 66: (1, {'@': 1175}), 67: (1, {'@': 1175}), 34: (1, {'@': 1175}), 36: (1, {'@': 1175}), 37: (1, {'@': 1175}), 68: (1, {'@': 1175}), 38: (1, {'@': 1175}), 69: (1, {'@': 1175}), 70: (1, {'@': 1175}), 71: (1, {'@': 1175}), 40: (1, {'@': 1175}), 72: (1, {'@': 1175}), 41: (1, {'@': 1175}), 73: (1, {'@': 1175}), 74: (1, {'@': 1175}), 75: (1, {'@': 1175})}, 2489: {43: (1, {'@': 454}), 1: (1, {'@': 454}), 2: (1, {'@': 454}), 44: (1, {'@': 454}), 45: (1, {'@': 454}), 47: (1, {'@': 454}), 48: (1, {'@': 454}), 4: (1, {'@': 454}), 49: (1, {'@': 454}), 50: (1, {'@': 454}), 51: (1, {'@': 454}), 6: (1, {'@': 454}), 52: (1, {'@': 454}), 8: (1, {'@': 454}), 7: (1, {'@': 454}), 9: (1, {'@': 454}), 53: (1, {'@': 454}), 11: (1, {'@': 454}), 54: (1, {'@': 454}), 55: (1, {'@': 454}), 15: (1, {'@': 454}), 17: (1, {'@': 454}), 57: (1, {'@': 454}), 18: (1, {'@': 454}), 58: (1, {'@': 454}), 59: (1, {'@': 454}), 21: (1, {'@': 454}), 22: (1, {'@': 454}), 60: (1, {'@': 454}), 61: (1, {'@': 454}), 126: (1, {'@': 454}), 62: (1, {'@': 454}), 23: (1, {'@': 454}), 25: (1, {'@': 454}), 26: (1, {'@': 454}), 63: (1, {'@': 454}), 27: (1, {'@': 454}), 28: (1, {'@': 454}), 29: (1, {'@': 454}), 30: (1, {'@': 454}), 31: (1, {'@': 454}), 33: (1, {'@': 454}), 64: (1, {'@': 454}), 66: (1, {'@': 454}), 67: (1, {'@': 454}), 34: (1, {'@': 454}), 36: (1, {'@': 454}), 37: (1, {'@': 454}), 68: (1, {'@': 454}), 38: (1, {'@': 454}), 69: (1, {'@': 454}), 70: (1, {'@': 454}), 71: (1, {'@': 454}), 40: (1, {'@': 454}), 72: (1, {'@': 454}), 41: (1, {'@': 454}), 73: (1, {'@': 454}), 74: (1, {'@': 454}), 75: (1, {'@': 454})}, 2490: {43: (1, {'@': 464}), 1: (1, {'@': 464}), 2: (1, {'@': 464}), 44: (1, {'@': 464}), 45: (1, {'@': 464}), 47: (1, {'@': 464}), 48: (1, {'@': 464}), 4: (1, {'@': 464}), 49: (1, {'@': 464}), 50: (1, {'@': 464}), 51: (1, {'@': 464}), 6: (1, {'@': 464}), 52: (1, {'@': 464}), 8: (1, {'@': 464}), 7: (1, {'@': 464}), 9: (1, {'@': 464}), 53: (1, {'@': 464}), 11: (1, {'@': 464}), 54: (1, {'@': 464}), 55: (1, {'@': 464}), 15: (1, {'@': 464}), 17: (1, {'@': 464}), 57: (1, {'@': 464}), 18: (1, {'@': 464}), 58: (1, {'@': 464}), 59: (1, {'@': 464}), 21: (1, {'@': 464}), 22: (1, {'@': 464}), 60: (1, {'@': 464}), 61: (1, {'@': 464}), 126: (1, {'@': 464}), 62: (1, {'@': 464}), 23: (1, {'@': 464}), 25: (1, {'@': 464}), 26: (1, {'@': 464}), 63: (1, {'@': 464}), 27: (1, {'@': 464}), 28: (1, {'@': 464}), 29: (1, {'@': 464}), 30: (1, {'@': 464}), 31: (1, {'@': 464}), 33: (1, {'@': 464}), 64: (1, {'@': 464}), 66: (1, {'@': 464}), 67: (1, {'@': 464}), 34: (1, {'@': 464}), 36: (1, {'@': 464}), 37: (1, {'@': 464}), 68: (1, {'@': 464}), 38: (1, {'@': 464}), 69: (1, {'@': 464}), 70: (1, {'@': 464}), 71: (1, {'@': 464}), 40: (1, {'@': 464}), 72: (1, {'@': 464}), 41: (1, {'@': 464}), 73: (1, {'@': 464}), 74: (1, {'@': 464}), 75: (1, {'@': 464})}, 2491: {144: (0, 2316), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 145: (0, 1286), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 86: (0, 1320), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2492: {43: (1, {'@': 485}), 1: (1, {'@': 485}), 2: (1, {'@': 485}), 44: (1, {'@': 485}), 45: (1, {'@': 485}), 47: (1, {'@': 485}), 48: (1, {'@': 485}), 4: (1, {'@': 485}), 49: (1, {'@': 485}), 50: (1, {'@': 485}), 51: (1, {'@': 485}), 6: (1, {'@': 485}), 52: (1, {'@': 485}), 8: (1, {'@': 485}), 7: (1, {'@': 485}), 9: (1, {'@': 485}), 53: (1, {'@': 485}), 11: (1, {'@': 485}), 54: (1, {'@': 485}), 55: (1, {'@': 485}), 15: (1, {'@': 485}), 17: (1, {'@': 485}), 57: (1, {'@': 485}), 18: (1, {'@': 485}), 58: (1, {'@': 485}), 59: (1, {'@': 485}), 21: (1, {'@': 485}), 22: (1, {'@': 485}), 60: (1, {'@': 485}), 61: (1, {'@': 485}), 126: (1, {'@': 485}), 62: (1, {'@': 485}), 23: (1, {'@': 485}), 25: (1, {'@': 485}), 26: (1, {'@': 485}), 63: (1, {'@': 485}), 27: (1, {'@': 485}), 28: (1, {'@': 485}), 29: (1, {'@': 485}), 30: (1, {'@': 485}), 31: (1, {'@': 485}), 33: (1, {'@': 485}), 64: (1, {'@': 485}), 66: (1, {'@': 485}), 67: (1, {'@': 485}), 34: (1, {'@': 485}), 36: (1, {'@': 485}), 37: (1, {'@': 485}), 68: (1, {'@': 485}), 38: (1, {'@': 485}), 69: (1, {'@': 485}), 70: (1, {'@': 485}), 71: (1, {'@': 485}), 40: (1, {'@': 485}), 72: (1, {'@': 485}), 41: (1, {'@': 485}), 73: (1, {'@': 485}), 74: (1, {'@': 485}), 75: (1, {'@': 485})}, 2493: {77: (0, 17), 78: (0, 1960), 79: (0, 1973), 12: (0, 396), 81: (0, 2295), 82: (0, 791), 83: (0, 809), 84: (0, 811), 85: (0, 816), 10: (0, 826), 194: (0, 1282), 87: (0, 842), 35: (0, 844), 88: (0, 848), 89: (0, 2384), 569: (0, 1419), 90: (0, 853), 91: (0, 863), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 56: (0, 783), 95: (0, 786), 96: (0, 789), 97: (0, 2370), 98: (0, 793), 19: (0, 800), 13: (0, 802), 32: (0, 807), 99: (0, 812), 100: (0, 817), 20: (0, 822), 102: (0, 823), 103: (0, 825), 105: (0, 830), 65: (0, 834), 106: (0, 838), 107: (0, 2409), 108: (0, 400), 109: (0, 390), 86: (0, 1421), 46: (0, 781), 80: (0, 2414), 110: (0, 799), 111: (0, 821), 14: (0, 399), 112: (0, 2376), 567: (0, 1424), 113: (0, 828), 114: (0, 832), 0: (0, 846), 42: (0, 858), 39: (0, 860), 115: (0, 44), 116: (0, 780), 706: (0, 1427), 5: (0, 787), 568: (0, 1430), 117: (0, 804), 24: (0, 814), 118: (0, 819), 119: (0, 836), 120: (0, 840), 122: (0, 850), 3: (0, 855), 123: (0, 856), 124: (0, 864)}, 2494: {60: (0, 229)}, 2495: {456: (0, 212), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 461: (0, 219), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 86: (0, 2314), 46: (0, 781), 458: (0, 215), 56: (0, 783), 459: (0, 216), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 463: (0, 224), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 462: (0, 223), 113: (0, 828), 460: (0, 1578), 105: (0, 830), 114: (0, 832), 65: (0, 834), 454: (0, 188), 455: (0, 210), 119: (0, 836), 120: (0, 840), 457: (0, 213), 106: (0, 838), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 144: (0, 221), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2496: {43: (1, {'@': 481}), 1: (1, {'@': 481}), 2: (1, {'@': 481}), 44: (1, {'@': 481}), 45: (1, {'@': 481}), 47: (1, {'@': 481}), 48: (1, {'@': 481}), 4: (1, {'@': 481}), 49: (1, {'@': 481}), 50: (1, {'@': 481}), 51: (1, {'@': 481}), 6: (1, {'@': 481}), 52: (1, {'@': 481}), 8: (1, {'@': 481}), 7: (1, {'@': 481}), 9: (1, {'@': 481}), 53: (1, {'@': 481}), 11: (1, {'@': 481}), 54: (1, {'@': 481}), 55: (1, {'@': 481}), 15: (1, {'@': 481}), 17: (1, {'@': 481}), 57: (1, {'@': 481}), 18: (1, {'@': 481}), 58: (1, {'@': 481}), 59: (1, {'@': 481}), 21: (1, {'@': 481}), 22: (1, {'@': 481}), 60: (1, {'@': 481}), 61: (1, {'@': 481}), 126: (1, {'@': 481}), 62: (1, {'@': 481}), 23: (1, {'@': 481}), 25: (1, {'@': 481}), 26: (1, {'@': 481}), 63: (1, {'@': 481}), 27: (1, {'@': 481}), 28: (1, {'@': 481}), 29: (1, {'@': 481}), 30: (1, {'@': 481}), 31: (1, {'@': 481}), 33: (1, {'@': 481}), 64: (1, {'@': 481}), 66: (1, {'@': 481}), 67: (1, {'@': 481}), 34: (1, {'@': 481}), 36: (1, {'@': 481}), 37: (1, {'@': 481}), 68: (1, {'@': 481}), 38: (1, {'@': 481}), 69: (1, {'@': 481}), 70: (1, {'@': 481}), 71: (1, {'@': 481}), 40: (1, {'@': 481}), 72: (1, {'@': 481}), 41: (1, {'@': 481}), 73: (1, {'@': 481}), 74: (1, {'@': 481}), 75: (1, {'@': 481})}, 2497: {146: (0, 2132)}, 2498: {43: (1, {'@': 446}), 1: (1, {'@': 446}), 2: (1, {'@': 446}), 44: (1, {'@': 446}), 45: (1, {'@': 446}), 47: (1, {'@': 446}), 48: (1, {'@': 446}), 4: (1, {'@': 446}), 49: (1, {'@': 446}), 50: (1, {'@': 446}), 51: (1, {'@': 446}), 6: (1, {'@': 446}), 52: (1, {'@': 446}), 8: (1, {'@': 446}), 7: (1, {'@': 446}), 9: (1, {'@': 446}), 53: (1, {'@': 446}), 11: (1, {'@': 446}), 54: (1, {'@': 446}), 55: (1, {'@': 446}), 15: (1, {'@': 446}), 17: (1, {'@': 446}), 57: (1, {'@': 446}), 18: (1, {'@': 446}), 58: (1, {'@': 446}), 59: (1, {'@': 446}), 21: (1, {'@': 446}), 22: (1, {'@': 446}), 60: (1, {'@': 446}), 61: (1, {'@': 446}), 126: (1, {'@': 446}), 62: (1, {'@': 446}), 23: (1, {'@': 446}), 25: (1, {'@': 446}), 26: (1, {'@': 446}), 63: (1, {'@': 446}), 27: (1, {'@': 446}), 28: (1, {'@': 446}), 29: (1, {'@': 446}), 30: (1, {'@': 446}), 31: (1, {'@': 446}), 33: (1, {'@': 446}), 64: (1, {'@': 446}), 66: (1, {'@': 446}), 67: (1, {'@': 446}), 34: (1, {'@': 446}), 36: (1, {'@': 446}), 37: (1, {'@': 446}), 68: (1, {'@': 446}), 38: (1, {'@': 446}), 69: (1, {'@': 446}), 70: (1, {'@': 446}), 71: (1, {'@': 446}), 40: (1, {'@': 446}), 72: (1, {'@': 446}), 41: (1, {'@': 446}), 73: (1, {'@': 446}), 74: (1, {'@': 446}), 75: (1, {'@': 446})}, 2499: {60: (0, 201)}, 2500: {43: (1, {'@': 473}), 1: (1, {'@': 473}), 2: (1, {'@': 473}), 44: (1, {'@': 473}), 45: (1, {'@': 473}), 47: (1, {'@': 473}), 48: (1, {'@': 473}), 4: (1, {'@': 473}), 49: (1, {'@': 473}), 50: (1, {'@': 473}), 51: (1, {'@': 473}), 6: (1, {'@': 473}), 52: (1, {'@': 473}), 8: (1, {'@': 473}), 7: (1, {'@': 473}), 9: (1, {'@': 473}), 53: (1, {'@': 473}), 11: (1, {'@': 473}), 54: (1, {'@': 473}), 55: (1, {'@': 473}), 15: (1, {'@': 473}), 17: (1, {'@': 473}), 57: (1, {'@': 473}), 18: (1, {'@': 473}), 58: (1, {'@': 473}), 59: (1, {'@': 473}), 21: (1, {'@': 473}), 22: (1, {'@': 473}), 60: (1, {'@': 473}), 61: (1, {'@': 473}), 126: (1, {'@': 473}), 62: (1, {'@': 473}), 23: (1, {'@': 473}), 25: (1, {'@': 473}), 26: (1, {'@': 473}), 63: (1, {'@': 473}), 27: (1, {'@': 473}), 28: (1, {'@': 473}), 29: (1, {'@': 473}), 30: (1, {'@': 473}), 31: (1, {'@': 473}), 33: (1, {'@': 473}), 64: (1, {'@': 473}), 66: (1, {'@': 473}), 67: (1, {'@': 473}), 34: (1, {'@': 473}), 36: (1, {'@': 473}), 37: (1, {'@': 473}), 68: (1, {'@': 473}), 38: (1, {'@': 473}), 69: (1, {'@': 473}), 70: (1, {'@': 473}), 71: (1, {'@': 473}), 40: (1, {'@': 473}), 72: (1, {'@': 473}), 41: (1, {'@': 473}), 73: (1, {'@': 473}), 74: (1, {'@': 473}), 75: (1, {'@': 473})}, 2501: {43: (1, {'@': 475}), 1: (1, {'@': 475}), 2: (1, {'@': 475}), 44: (1, {'@': 475}), 45: (1, {'@': 475}), 47: (1, {'@': 475}), 48: (1, {'@': 475}), 4: (1, {'@': 475}), 49: (1, {'@': 475}), 50: (1, {'@': 475}), 51: (1, {'@': 475}), 6: (1, {'@': 475}), 52: (1, {'@': 475}), 8: (1, {'@': 475}), 7: (1, {'@': 475}), 9: (1, {'@': 475}), 53: (1, {'@': 475}), 11: (1, {'@': 475}), 54: (1, {'@': 475}), 55: (1, {'@': 475}), 15: (1, {'@': 475}), 17: (1, {'@': 475}), 57: (1, {'@': 475}), 18: (1, {'@': 475}), 58: (1, {'@': 475}), 59: (1, {'@': 475}), 21: (1, {'@': 475}), 22: (1, {'@': 475}), 60: (1, {'@': 475}), 61: (1, {'@': 475}), 126: (1, {'@': 475}), 62: (1, {'@': 475}), 23: (1, {'@': 475}), 25: (1, {'@': 475}), 26: (1, {'@': 475}), 63: (1, {'@': 475}), 27: (1, {'@': 475}), 28: (1, {'@': 475}), 29: (1, {'@': 475}), 30: (1, {'@': 475}), 31: (1, {'@': 475}), 33: (1, {'@': 475}), 64: (1, {'@': 475}), 66: (1, {'@': 475}), 67: (1, {'@': 475}), 34: (1, {'@': 475}), 36: (1, {'@': 475}), 37: (1, {'@': 475}), 68: (1, {'@': 475}), 38: (1, {'@': 475}), 69: (1, {'@': 475}), 70: (1, {'@': 475}), 71: (1, {'@': 475}), 40: (1, {'@': 475}), 72: (1, {'@': 475}), 41: (1, {'@': 475}), 73: (1, {'@': 475}), 74: (1, {'@': 475}), 75: (1, {'@': 475})}, 2502: {57: (1, {'@': 1073}), 60: (1, {'@': 1073})}, 2503: {60: (1, {'@': 417}), 57: (1, {'@': 417})}, 2504: {77: (0, 17), 78: (0, 1960), 79: (0, 1973), 12: (0, 396), 576: (0, 1301), 82: (0, 791), 83: (0, 809), 84: (0, 811), 85: (0, 816), 570: (0, 1330), 256: (0, 1332), 10: (0, 826), 87: (0, 842), 35: (0, 844), 571: (0, 1334), 88: (0, 848), 90: (0, 853), 91: (0, 863), 144: (0, 2316), 474: (0, 1337), 92: (0, 1944), 379: (0, 1341), 255: (0, 1221), 572: (0, 1345), 573: (0, 1349), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 588: (0, 1353), 56: (0, 783), 95: (0, 786), 574: (0, 1358), 96: (0, 789), 98: (0, 793), 19: (0, 800), 13: (0, 802), 32: (0, 807), 376: (0, 1361), 99: (0, 812), 100: (0, 817), 20: (0, 822), 102: (0, 823), 103: (0, 825), 575: (0, 1365), 586: (0, 1369), 105: (0, 830), 145: (0, 1372), 65: (0, 834), 577: (0, 1376), 106: (0, 838), 584: (0, 1378), 578: (0, 1382), 579: (0, 1386), 108: (0, 400), 109: (0, 390), 46: (0, 781), 580: (0, 1390), 110: (0, 799), 585: (0, 1394), 111: (0, 821), 14: (0, 399), 113: (0, 828), 114: (0, 832), 581: (0, 1398), 380: (0, 1402), 707: (0, 1405), 0: (0, 846), 42: (0, 858), 39: (0, 860), 115: (0, 44), 86: (0, 1408), 582: (0, 1412), 587: (0, 1415), 116: (0, 780), 5: (0, 787), 117: (0, 804), 24: (0, 814), 118: (0, 819), 119: (0, 836), 120: (0, 840), 122: (0, 850), 3: (0, 855), 123: (0, 856), 124: (0, 864)}, 2505: {43: (1, {'@': 484}), 1: (1, {'@': 484}), 2: (1, {'@': 484}), 44: (1, {'@': 484}), 45: (1, {'@': 484}), 47: (1, {'@': 484}), 48: (1, {'@': 484}), 4: (1, {'@': 484}), 49: (1, {'@': 484}), 50: (1, {'@': 484}), 51: (1, {'@': 484}), 6: (1, {'@': 484}), 52: (1, {'@': 484}), 8: (1, {'@': 484}), 7: (1, {'@': 484}), 9: (1, {'@': 484}), 53: (1, {'@': 484}), 11: (1, {'@': 484}), 54: (1, {'@': 484}), 55: (1, {'@': 484}), 15: (1, {'@': 484}), 17: (1, {'@': 484}), 57: (1, {'@': 484}), 18: (1, {'@': 484}), 58: (1, {'@': 484}), 59: (1, {'@': 484}), 21: (1, {'@': 484}), 22: (1, {'@': 484}), 60: (1, {'@': 484}), 61: (1, {'@': 484}), 126: (1, {'@': 484}), 62: (1, {'@': 484}), 23: (1, {'@': 484}), 25: (1, {'@': 484}), 26: (1, {'@': 484}), 63: (1, {'@': 484}), 27: (1, {'@': 484}), 28: (1, {'@': 484}), 29: (1, {'@': 484}), 30: (1, {'@': 484}), 31: (1, {'@': 484}), 33: (1, {'@': 484}), 64: (1, {'@': 484}), 66: (1, {'@': 484}), 67: (1, {'@': 484}), 34: (1, {'@': 484}), 36: (1, {'@': 484}), 37: (1, {'@': 484}), 68: (1, {'@': 484}), 38: (1, {'@': 484}), 69: (1, {'@': 484}), 70: (1, {'@': 484}), 71: (1, {'@': 484}), 40: (1, {'@': 484}), 72: (1, {'@': 484}), 41: (1, {'@': 484}), 73: (1, {'@': 484}), 74: (1, {'@': 484}), 75: (1, {'@': 484})}, 2506: {60: (0, 220)}, 2507: {43: (1, {'@': 451}), 1: (1, {'@': 451}), 2: (1, {'@': 451}), 44: (1, {'@': 451}), 45: (1, {'@': 451}), 47: (1, {'@': 451}), 48: (1, {'@': 451}), 4: (1, {'@': 451}), 49: (1, {'@': 451}), 50: (1, {'@': 451}), 51: (1, {'@': 451}), 6: (1, {'@': 451}), 52: (1, {'@': 451}), 8: (1, {'@': 451}), 7: (1, {'@': 451}), 9: (1, {'@': 451}), 53: (1, {'@': 451}), 11: (1, {'@': 451}), 54: (1, {'@': 451}), 55: (1, {'@': 451}), 15: (1, {'@': 451}), 17: (1, {'@': 451}), 57: (1, {'@': 451}), 18: (1, {'@': 451}), 58: (1, {'@': 451}), 59: (1, {'@': 451}), 21: (1, {'@': 451}), 22: (1, {'@': 451}), 60: (1, {'@': 451}), 61: (1, {'@': 451}), 126: (1, {'@': 451}), 62: (1, {'@': 451}), 23: (1, {'@': 451}), 25: (1, {'@': 451}), 26: (1, {'@': 451}), 63: (1, {'@': 451}), 27: (1, {'@': 451}), 28: (1, {'@': 451}), 29: (1, {'@': 451}), 30: (1, {'@': 451}), 31: (1, {'@': 451}), 33: (1, {'@': 451}), 64: (1, {'@': 451}), 66: (1, {'@': 451}), 67: (1, {'@': 451}), 34: (1, {'@': 451}), 36: (1, {'@': 451}), 37: (1, {'@': 451}), 68: (1, {'@': 451}), 38: (1, {'@': 451}), 69: (1, {'@': 451}), 70: (1, {'@': 451}), 71: (1, {'@': 451}), 40: (1, {'@': 451}), 72: (1, {'@': 451}), 41: (1, {'@': 451}), 73: (1, {'@': 451}), 74: (1, {'@': 451}), 75: (1, {'@': 451})}, 2508: {43: (1, {'@': 440}), 1: (1, {'@': 440}), 2: (1, {'@': 440}), 44: (1, {'@': 440}), 45: (1, {'@': 440}), 47: (1, {'@': 440}), 48: (1, {'@': 440}), 4: (1, {'@': 440}), 49: (1, {'@': 440}), 50: (1, {'@': 440}), 51: (1, {'@': 440}), 6: (1, {'@': 440}), 52: (1, {'@': 440}), 8: (1, {'@': 440}), 7: (1, {'@': 440}), 9: (1, {'@': 440}), 53: (1, {'@': 440}), 11: (1, {'@': 440}), 54: (1, {'@': 440}), 55: (1, {'@': 440}), 15: (1, {'@': 440}), 17: (1, {'@': 440}), 57: (1, {'@': 440}), 18: (1, {'@': 440}), 58: (1, {'@': 440}), 59: (1, {'@': 440}), 21: (1, {'@': 440}), 22: (1, {'@': 440}), 60: (1, {'@': 440}), 61: (1, {'@': 440}), 126: (1, {'@': 440}), 62: (1, {'@': 440}), 23: (1, {'@': 440}), 25: (1, {'@': 440}), 26: (1, {'@': 440}), 63: (1, {'@': 440}), 27: (1, {'@': 440}), 28: (1, {'@': 440}), 29: (1, {'@': 440}), 30: (1, {'@': 440}), 31: (1, {'@': 440}), 33: (1, {'@': 440}), 64: (1, {'@': 440}), 66: (1, {'@': 440}), 67: (1, {'@': 440}), 34: (1, {'@': 440}), 36: (1, {'@': 440}), 37: (1, {'@': 440}), 68: (1, {'@': 440}), 38: (1, {'@': 440}), 69: (1, {'@': 440}), 70: (1, {'@': 440}), 71: (1, {'@': 440}), 40: (1, {'@': 440}), 72: (1, {'@': 440}), 41: (1, {'@': 440}), 73: (1, {'@': 440}), 74: (1, {'@': 440}), 75: (1, {'@': 440})}, 2509: {146: (0, 222)}, 2510: {43: (1, {'@': 468}), 1: (1, {'@': 468}), 2: (1, {'@': 468}), 44: (1, {'@': 468}), 45: (1, {'@': 468}), 47: (1, {'@': 468}), 48: (1, {'@': 468}), 4: (1, {'@': 468}), 49: (1, {'@': 468}), 50: (1, {'@': 468}), 51: (1, {'@': 468}), 6: (1, {'@': 468}), 52: (1, {'@': 468}), 8: (1, {'@': 468}), 7: (1, {'@': 468}), 9: (1, {'@': 468}), 53: (1, {'@': 468}), 11: (1, {'@': 468}), 54: (1, {'@': 468}), 55: (1, {'@': 468}), 15: (1, {'@': 468}), 17: (1, {'@': 468}), 57: (1, {'@': 468}), 18: (1, {'@': 468}), 58: (1, {'@': 468}), 59: (1, {'@': 468}), 21: (1, {'@': 468}), 22: (1, {'@': 468}), 60: (1, {'@': 468}), 61: (1, {'@': 468}), 126: (1, {'@': 468}), 62: (1, {'@': 468}), 23: (1, {'@': 468}), 25: (1, {'@': 468}), 26: (1, {'@': 468}), 63: (1, {'@': 468}), 27: (1, {'@': 468}), 28: (1, {'@': 468}), 29: (1, {'@': 468}), 30: (1, {'@': 468}), 31: (1, {'@': 468}), 33: (1, {'@': 468}), 64: (1, {'@': 468}), 66: (1, {'@': 468}), 67: (1, {'@': 468}), 34: (1, {'@': 468}), 36: (1, {'@': 468}), 37: (1, {'@': 468}), 68: (1, {'@': 468}), 38: (1, {'@': 468}), 69: (1, {'@': 468}), 70: (1, {'@': 468}), 71: (1, {'@': 468}), 40: (1, {'@': 468}), 72: (1, {'@': 468}), 41: (1, {'@': 468}), 73: (1, {'@': 468}), 74: (1, {'@': 468}), 75: (1, {'@': 468})}, 2511: {43: (1, {'@': 490}), 1: (1, {'@': 490}), 2: (1, {'@': 490}), 44: (1, {'@': 490}), 45: (1, {'@': 490}), 47: (1, {'@': 490}), 48: (1, {'@': 490}), 4: (1, {'@': 490}), 49: (1, {'@': 490}), 50: (1, {'@': 490}), 51: (1, {'@': 490}), 6: (1, {'@': 490}), 52: (1, {'@': 490}), 8: (1, {'@': 490}), 7: (1, {'@': 490}), 9: (1, {'@': 490}), 53: (1, {'@': 490}), 11: (1, {'@': 490}), 54: (1, {'@': 490}), 55: (1, {'@': 490}), 15: (1, {'@': 490}), 17: (1, {'@': 490}), 57: (1, {'@': 490}), 18: (1, {'@': 490}), 58: (1, {'@': 490}), 59: (1, {'@': 490}), 21: (1, {'@': 490}), 22: (1, {'@': 490}), 60: (1, {'@': 490}), 61: (1, {'@': 490}), 126: (1, {'@': 490}), 62: (1, {'@': 490}), 23: (1, {'@': 490}), 25: (1, {'@': 490}), 26: (1, {'@': 490}), 63: (1, {'@': 490}), 27: (1, {'@': 490}), 28: (1, {'@': 490}), 29: (1, {'@': 490}), 30: (1, {'@': 490}), 31: (1, {'@': 490}), 33: (1, {'@': 490}), 64: (1, {'@': 490}), 66: (1, {'@': 490}), 67: (1, {'@': 490}), 34: (1, {'@': 490}), 36: (1, {'@': 490}), 37: (1, {'@': 490}), 68: (1, {'@': 490}), 38: (1, {'@': 490}), 69: (1, {'@': 490}), 70: (1, {'@': 490}), 71: (1, {'@': 490}), 40: (1, {'@': 490}), 72: (1, {'@': 490}), 41: (1, {'@': 490}), 73: (1, {'@': 490}), 74: (1, {'@': 490}), 75: (1, {'@': 490})}, 2512: {60: (0, 857)}, 2513: {43: (1, {'@': 465}), 1: (1, {'@': 465}), 2: (1, {'@': 465}), 44: (1, {'@': 465}), 45: (1, {'@': 465}), 47: (1, {'@': 465}), 48: (1, {'@': 465}), 4: (1, {'@': 465}), 49: (1, {'@': 465}), 50: (1, {'@': 465}), 51: (1, {'@': 465}), 6: (1, {'@': 465}), 52: (1, {'@': 465}), 8: (1, {'@': 465}), 7: (1, {'@': 465}), 9: (1, {'@': 465}), 53: (1, {'@': 465}), 11: (1, {'@': 465}), 54: (1, {'@': 465}), 55: (1, {'@': 465}), 15: (1, {'@': 465}), 17: (1, {'@': 465}), 57: (1, {'@': 465}), 18: (1, {'@': 465}), 58: (1, {'@': 465}), 59: (1, {'@': 465}), 21: (1, {'@': 465}), 22: (1, {'@': 465}), 60: (1, {'@': 465}), 61: (1, {'@': 465}), 126: (1, {'@': 465}), 62: (1, {'@': 465}), 23: (1, {'@': 465}), 25: (1, {'@': 465}), 26: (1, {'@': 465}), 63: (1, {'@': 465}), 27: (1, {'@': 465}), 28: (1, {'@': 465}), 29: (1, {'@': 465}), 30: (1, {'@': 465}), 31: (1, {'@': 465}), 33: (1, {'@': 465}), 64: (1, {'@': 465}), 66: (1, {'@': 465}), 67: (1, {'@': 465}), 34: (1, {'@': 465}), 36: (1, {'@': 465}), 37: (1, {'@': 465}), 68: (1, {'@': 465}), 38: (1, {'@': 465}), 69: (1, {'@': 465}), 70: (1, {'@': 465}), 71: (1, {'@': 465}), 40: (1, {'@': 465}), 72: (1, {'@': 465}), 41: (1, {'@': 465}), 73: (1, {'@': 465}), 74: (1, {'@': 465}), 75: (1, {'@': 465})}, 2514: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 86: (0, 1435), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 194: (0, 1439), 124: (0, 864)}, 2515: {43: (1, {'@': 444}), 1: (1, {'@': 444}), 2: (1, {'@': 444}), 44: (1, {'@': 444}), 45: (1, {'@': 444}), 47: (1, {'@': 444}), 48: (1, {'@': 444}), 4: (1, {'@': 444}), 49: (1, {'@': 444}), 50: (1, {'@': 444}), 51: (1, {'@': 444}), 6: (1, {'@': 444}), 52: (1, {'@': 444}), 8: (1, {'@': 444}), 7: (1, {'@': 444}), 9: (1, {'@': 444}), 53: (1, {'@': 444}), 11: (1, {'@': 444}), 54: (1, {'@': 444}), 55: (1, {'@': 444}), 15: (1, {'@': 444}), 17: (1, {'@': 444}), 57: (1, {'@': 444}), 18: (1, {'@': 444}), 58: (1, {'@': 444}), 59: (1, {'@': 444}), 21: (1, {'@': 444}), 22: (1, {'@': 444}), 60: (1, {'@': 444}), 61: (1, {'@': 444}), 126: (1, {'@': 444}), 62: (1, {'@': 444}), 23: (1, {'@': 444}), 25: (1, {'@': 444}), 26: (1, {'@': 444}), 63: (1, {'@': 444}), 27: (1, {'@': 444}), 28: (1, {'@': 444}), 29: (1, {'@': 444}), 30: (1, {'@': 444}), 31: (1, {'@': 444}), 33: (1, {'@': 444}), 64: (1, {'@': 444}), 66: (1, {'@': 444}), 67: (1, {'@': 444}), 34: (1, {'@': 444}), 36: (1, {'@': 444}), 37: (1, {'@': 444}), 68: (1, {'@': 444}), 38: (1, {'@': 444}), 69: (1, {'@': 444}), 70: (1, {'@': 444}), 71: (1, {'@': 444}), 40: (1, {'@': 444}), 72: (1, {'@': 444}), 41: (1, {'@': 444}), 73: (1, {'@': 444}), 74: (1, {'@': 444}), 75: (1, {'@': 444})}, 2516: {146: (0, 227)}, 2517: {43: (1, {'@': 488}), 1: (1, {'@': 488}), 2: (1, {'@': 488}), 44: (1, {'@': 488}), 45: (1, {'@': 488}), 47: (1, {'@': 488}), 48: (1, {'@': 488}), 4: (1, {'@': 488}), 49: (1, {'@': 488}), 50: (1, {'@': 488}), 51: (1, {'@': 488}), 6: (1, {'@': 488}), 52: (1, {'@': 488}), 8: (1, {'@': 488}), 7: (1, {'@': 488}), 9: (1, {'@': 488}), 53: (1, {'@': 488}), 11: (1, {'@': 488}), 54: (1, {'@': 488}), 55: (1, {'@': 488}), 15: (1, {'@': 488}), 17: (1, {'@': 488}), 57: (1, {'@': 488}), 18: (1, {'@': 488}), 58: (1, {'@': 488}), 59: (1, {'@': 488}), 21: (1, {'@': 488}), 22: (1, {'@': 488}), 60: (1, {'@': 488}), 61: (1, {'@': 488}), 126: (1, {'@': 488}), 62: (1, {'@': 488}), 23: (1, {'@': 488}), 25: (1, {'@': 488}), 26: (1, {'@': 488}), 63: (1, {'@': 488}), 27: (1, {'@': 488}), 28: (1, {'@': 488}), 29: (1, {'@': 488}), 30: (1, {'@': 488}), 31: (1, {'@': 488}), 33: (1, {'@': 488}), 64: (1, {'@': 488}), 66: (1, {'@': 488}), 67: (1, {'@': 488}), 34: (1, {'@': 488}), 36: (1, {'@': 488}), 37: (1, {'@': 488}), 68: (1, {'@': 488}), 38: (1, {'@': 488}), 69: (1, {'@': 488}), 70: (1, {'@': 488}), 71: (1, {'@': 488}), 40: (1, {'@': 488}), 72: (1, {'@': 488}), 41: (1, {'@': 488}), 73: (1, {'@': 488}), 74: (1, {'@': 488}), 75: (1, {'@': 488})}, 2518: {43: (1, {'@': 477}), 1: (1, {'@': 477}), 2: (1, {'@': 477}), 44: (1, {'@': 477}), 45: (1, {'@': 477}), 47: (1, {'@': 477}), 48: (1, {'@': 477}), 4: (1, {'@': 477}), 49: (1, {'@': 477}), 50: (1, {'@': 477}), 51: (1, {'@': 477}), 6: (1, {'@': 477}), 52: (1, {'@': 477}), 8: (1, {'@': 477}), 7: (1, {'@': 477}), 9: (1, {'@': 477}), 53: (1, {'@': 477}), 11: (1, {'@': 477}), 54: (1, {'@': 477}), 55: (1, {'@': 477}), 15: (1, {'@': 477}), 17: (1, {'@': 477}), 57: (1, {'@': 477}), 18: (1, {'@': 477}), 58: (1, {'@': 477}), 59: (1, {'@': 477}), 21: (1, {'@': 477}), 22: (1, {'@': 477}), 60: (1, {'@': 477}), 61: (1, {'@': 477}), 126: (1, {'@': 477}), 62: (1, {'@': 477}), 23: (1, {'@': 477}), 25: (1, {'@': 477}), 26: (1, {'@': 477}), 63: (1, {'@': 477}), 27: (1, {'@': 477}), 28: (1, {'@': 477}), 29: (1, {'@': 477}), 30: (1, {'@': 477}), 31: (1, {'@': 477}), 33: (1, {'@': 477}), 64: (1, {'@': 477}), 66: (1, {'@': 477}), 67: (1, {'@': 477}), 34: (1, {'@': 477}), 36: (1, {'@': 477}), 37: (1, {'@': 477}), 68: (1, {'@': 477}), 38: (1, {'@': 477}), 69: (1, {'@': 477}), 70: (1, {'@': 477}), 71: (1, {'@': 477}), 40: (1, {'@': 477}), 72: (1, {'@': 477}), 41: (1, {'@': 477}), 73: (1, {'@': 477}), 74: (1, {'@': 477}), 75: (1, {'@': 477})}, 2519: {43: (1, {'@': 476}), 1: (1, {'@': 476}), 2: (1, {'@': 476}), 44: (1, {'@': 476}), 45: (1, {'@': 476}), 47: (1, {'@': 476}), 48: (1, {'@': 476}), 4: (1, {'@': 476}), 49: (1, {'@': 476}), 50: (1, {'@': 476}), 51: (1, {'@': 476}), 6: (1, {'@': 476}), 52: (1, {'@': 476}), 8: (1, {'@': 476}), 7: (1, {'@': 476}), 9: (1, {'@': 476}), 53: (1, {'@': 476}), 11: (1, {'@': 476}), 54: (1, {'@': 476}), 55: (1, {'@': 476}), 15: (1, {'@': 476}), 17: (1, {'@': 476}), 57: (1, {'@': 476}), 18: (1, {'@': 476}), 58: (1, {'@': 476}), 59: (1, {'@': 476}), 21: (1, {'@': 476}), 22: (1, {'@': 476}), 60: (1, {'@': 476}), 61: (1, {'@': 476}), 126: (1, {'@': 476}), 62: (1, {'@': 476}), 23: (1, {'@': 476}), 25: (1, {'@': 476}), 26: (1, {'@': 476}), 63: (1, {'@': 476}), 27: (1, {'@': 476}), 28: (1, {'@': 476}), 29: (1, {'@': 476}), 30: (1, {'@': 476}), 31: (1, {'@': 476}), 33: (1, {'@': 476}), 64: (1, {'@': 476}), 66: (1, {'@': 476}), 67: (1, {'@': 476}), 34: (1, {'@': 476}), 36: (1, {'@': 476}), 37: (1, {'@': 476}), 68: (1, {'@': 476}), 38: (1, {'@': 476}), 69: (1, {'@': 476}), 70: (1, {'@': 476}), 71: (1, {'@': 476}), 40: (1, {'@': 476}), 72: (1, {'@': 476}), 41: (1, {'@': 476}), 73: (1, {'@': 476}), 74: (1, {'@': 476}), 75: (1, {'@': 476})}, 2520: {57: (1, {'@': 802}), 60: (1, {'@': 802})}, 2521: {198: (0, 393), 22: (0, 389), 53: (0, 387), 33: (0, 383), 7: (0, 45), 44: (0, 358), 41: (0, 372), 62: (0, 367), 21: (0, 366), 59: (0, 363), 200: (0, 395), 180: (0, 359), 201: (0, 354), 183: (0, 351), 202: (0, 350), 164: (0, 347), 75: (0, 341), 199: (0, 1304), 203: (0, 402), 204: (0, 304), 49: (0, 335), 205: (0, 334), 28: (0, 33), 206: (0, 330), 61: (0, 25), 23: (0, 327), 185: (0, 324), 207: (0, 320), 208: (0, 303), 40: (0, 1756), 69: (0, 1760), 73: (0, 1763), 172: (0, 1765), 210: (0, 1769), 211: (0, 1774), 6: (0, 20), 212: (0, 1778), 25: (0, 1783), 213: (0, 1788)}, 2522: {43: (1, {'@': 462}), 1: (1, {'@': 462}), 2: (1, {'@': 462}), 44: (1, {'@': 462}), 45: (1, {'@': 462}), 47: (1, {'@': 462}), 48: (1, {'@': 462}), 4: (1, {'@': 462}), 49: (1, {'@': 462}), 50: (1, {'@': 462}), 51: (1, {'@': 462}), 6: (1, {'@': 462}), 52: (1, {'@': 462}), 8: (1, {'@': 462}), 7: (1, {'@': 462}), 9: (1, {'@': 462}), 53: (1, {'@': 462}), 11: (1, {'@': 462}), 54: (1, {'@': 462}), 55: (1, {'@': 462}), 15: (1, {'@': 462}), 17: (1, {'@': 462}), 57: (1, {'@': 462}), 18: (1, {'@': 462}), 58: (1, {'@': 462}), 59: (1, {'@': 462}), 21: (1, {'@': 462}), 22: (1, {'@': 462}), 60: (1, {'@': 462}), 61: (1, {'@': 462}), 126: (1, {'@': 462}), 62: (1, {'@': 462}), 23: (1, {'@': 462}), 25: (1, {'@': 462}), 26: (1, {'@': 462}), 63: (1, {'@': 462}), 27: (1, {'@': 462}), 28: (1, {'@': 462}), 29: (1, {'@': 462}), 30: (1, {'@': 462}), 31: (1, {'@': 462}), 33: (1, {'@': 462}), 64: (1, {'@': 462}), 66: (1, {'@': 462}), 67: (1, {'@': 462}), 34: (1, {'@': 462}), 36: (1, {'@': 462}), 37: (1, {'@': 462}), 68: (1, {'@': 462}), 38: (1, {'@': 462}), 69: (1, {'@': 462}), 70: (1, {'@': 462}), 71: (1, {'@': 462}), 40: (1, {'@': 462}), 72: (1, {'@': 462}), 41: (1, {'@': 462}), 73: (1, {'@': 462}), 74: (1, {'@': 462}), 75: (1, {'@': 462})}, 2523: {57: (1, {'@': 804}), 60: (1, {'@': 804})}, 2524: {43: (1, {'@': 443}), 1: (1, {'@': 443}), 2: (1, {'@': 443}), 44: (1, {'@': 443}), 45: (1, {'@': 443}), 47: (1, {'@': 443}), 48: (1, {'@': 443}), 4: (1, {'@': 443}), 49: (1, {'@': 443}), 50: (1, {'@': 443}), 51: (1, {'@': 443}), 6: (1, {'@': 443}), 52: (1, {'@': 443}), 8: (1, {'@': 443}), 7: (1, {'@': 443}), 9: (1, {'@': 443}), 53: (1, {'@': 443}), 11: (1, {'@': 443}), 54: (1, {'@': 443}), 55: (1, {'@': 443}), 15: (1, {'@': 443}), 17: (1, {'@': 443}), 57: (1, {'@': 443}), 18: (1, {'@': 443}), 58: (1, {'@': 443}), 59: (1, {'@': 443}), 21: (1, {'@': 443}), 22: (1, {'@': 443}), 60: (1, {'@': 443}), 61: (1, {'@': 443}), 126: (1, {'@': 443}), 62: (1, {'@': 443}), 23: (1, {'@': 443}), 25: (1, {'@': 443}), 26: (1, {'@': 443}), 63: (1, {'@': 443}), 27: (1, {'@': 443}), 28: (1, {'@': 443}), 29: (1, {'@': 443}), 30: (1, {'@': 443}), 31: (1, {'@': 443}), 33: (1, {'@': 443}), 64: (1, {'@': 443}), 66: (1, {'@': 443}), 67: (1, {'@': 443}), 34: (1, {'@': 443}), 36: (1, {'@': 443}), 37: (1, {'@': 443}), 68: (1, {'@': 443}), 38: (1, {'@': 443}), 69: (1, {'@': 443}), 70: (1, {'@': 443}), 71: (1, {'@': 443}), 40: (1, {'@': 443}), 72: (1, {'@': 443}), 41: (1, {'@': 443}), 73: (1, {'@': 443}), 74: (1, {'@': 443}), 75: (1, {'@': 443})}, 2525: {60: (0, 231)}, 2526: {43: (1, {'@': 489}), 1: (1, {'@': 489}), 2: (1, {'@': 489}), 44: (1, {'@': 489}), 45: (1, {'@': 489}), 47: (1, {'@': 489}), 48: (1, {'@': 489}), 4: (1, {'@': 489}), 49: (1, {'@': 489}), 50: (1, {'@': 489}), 51: (1, {'@': 489}), 6: (1, {'@': 489}), 52: (1, {'@': 489}), 8: (1, {'@': 489}), 7: (1, {'@': 489}), 9: (1, {'@': 489}), 53: (1, {'@': 489}), 11: (1, {'@': 489}), 54: (1, {'@': 489}), 55: (1, {'@': 489}), 15: (1, {'@': 489}), 17: (1, {'@': 489}), 57: (1, {'@': 489}), 18: (1, {'@': 489}), 58: (1, {'@': 489}), 59: (1, {'@': 489}), 21: (1, {'@': 489}), 22: (1, {'@': 489}), 60: (1, {'@': 489}), 61: (1, {'@': 489}), 126: (1, {'@': 489}), 62: (1, {'@': 489}), 23: (1, {'@': 489}), 25: (1, {'@': 489}), 26: (1, {'@': 489}), 63: (1, {'@': 489}), 27: (1, {'@': 489}), 28: (1, {'@': 489}), 29: (1, {'@': 489}), 30: (1, {'@': 489}), 31: (1, {'@': 489}), 33: (1, {'@': 489}), 64: (1, {'@': 489}), 66: (1, {'@': 489}), 67: (1, {'@': 489}), 34: (1, {'@': 489}), 36: (1, {'@': 489}), 37: (1, {'@': 489}), 68: (1, {'@': 489}), 38: (1, {'@': 489}), 69: (1, {'@': 489}), 70: (1, {'@': 489}), 71: (1, {'@': 489}), 40: (1, {'@': 489}), 72: (1, {'@': 489}), 41: (1, {'@': 489}), 73: (1, {'@': 489}), 74: (1, {'@': 489}), 75: (1, {'@': 489})}, 2527: {146: (0, 232)}, 2528: {43: (1, {'@': 469}), 1: (1, {'@': 469}), 2: (1, {'@': 469}), 44: (1, {'@': 469}), 45: (1, {'@': 469}), 47: (1, {'@': 469}), 48: (1, {'@': 469}), 4: (1, {'@': 469}), 49: (1, {'@': 469}), 50: (1, {'@': 469}), 51: (1, {'@': 469}), 6: (1, {'@': 469}), 52: (1, {'@': 469}), 8: (1, {'@': 469}), 7: (1, {'@': 469}), 9: (1, {'@': 469}), 53: (1, {'@': 469}), 11: (1, {'@': 469}), 54: (1, {'@': 469}), 55: (1, {'@': 469}), 15: (1, {'@': 469}), 17: (1, {'@': 469}), 57: (1, {'@': 469}), 18: (1, {'@': 469}), 58: (1, {'@': 469}), 59: (1, {'@': 469}), 21: (1, {'@': 469}), 22: (1, {'@': 469}), 60: (1, {'@': 469}), 61: (1, {'@': 469}), 126: (1, {'@': 469}), 62: (1, {'@': 469}), 23: (1, {'@': 469}), 25: (1, {'@': 469}), 26: (1, {'@': 469}), 63: (1, {'@': 469}), 27: (1, {'@': 469}), 28: (1, {'@': 469}), 29: (1, {'@': 469}), 30: (1, {'@': 469}), 31: (1, {'@': 469}), 33: (1, {'@': 469}), 64: (1, {'@': 469}), 66: (1, {'@': 469}), 67: (1, {'@': 469}), 34: (1, {'@': 469}), 36: (1, {'@': 469}), 37: (1, {'@': 469}), 68: (1, {'@': 469}), 38: (1, {'@': 469}), 69: (1, {'@': 469}), 70: (1, {'@': 469}), 71: (1, {'@': 469}), 40: (1, {'@': 469}), 72: (1, {'@': 469}), 41: (1, {'@': 469}), 73: (1, {'@': 469}), 74: (1, {'@': 469}), 75: (1, {'@': 469})}, 2529: {57: (1, {'@': 1086}), 60: (1, {'@': 1086})}, 2530: {43: (1, {'@': 486}), 1: (1, {'@': 486}), 2: (1, {'@': 486}), 44: (1, {'@': 486}), 45: (1, {'@': 486}), 47: (1, {'@': 486}), 48: (1, {'@': 486}), 4: (1, {'@': 486}), 49: (1, {'@': 486}), 50: (1, {'@': 486}), 51: (1, {'@': 486}), 6: (1, {'@': 486}), 52: (1, {'@': 486}), 8: (1, {'@': 486}), 7: (1, {'@': 486}), 9: (1, {'@': 486}), 53: (1, {'@': 486}), 11: (1, {'@': 486}), 54: (1, {'@': 486}), 55: (1, {'@': 486}), 15: (1, {'@': 486}), 17: (1, {'@': 486}), 57: (1, {'@': 486}), 18: (1, {'@': 486}), 58: (1, {'@': 486}), 59: (1, {'@': 486}), 21: (1, {'@': 486}), 22: (1, {'@': 486}), 60: (1, {'@': 486}), 61: (1, {'@': 486}), 126: (1, {'@': 486}), 62: (1, {'@': 486}), 23: (1, {'@': 486}), 25: (1, {'@': 486}), 26: (1, {'@': 486}), 63: (1, {'@': 486}), 27: (1, {'@': 486}), 28: (1, {'@': 486}), 29: (1, {'@': 486}), 30: (1, {'@': 486}), 31: (1, {'@': 486}), 33: (1, {'@': 486}), 64: (1, {'@': 486}), 66: (1, {'@': 486}), 67: (1, {'@': 486}), 34: (1, {'@': 486}), 36: (1, {'@': 486}), 37: (1, {'@': 486}), 68: (1, {'@': 486}), 38: (1, {'@': 486}), 69: (1, {'@': 486}), 70: (1, {'@': 486}), 71: (1, {'@': 486}), 40: (1, {'@': 486}), 72: (1, {'@': 486}), 41: (1, {'@': 486}), 73: (1, {'@': 486}), 74: (1, {'@': 486}), 75: (1, {'@': 486})}, 2531: {57: (1, {'@': 1208}), 60: (1, {'@': 1208})}, 2532: {43: (1, {'@': 450}), 1: (1, {'@': 450}), 2: (1, {'@': 450}), 44: (1, {'@': 450}), 45: (1, {'@': 450}), 47: (1, {'@': 450}), 48: (1, {'@': 450}), 4: (1, {'@': 450}), 49: (1, {'@': 450}), 50: (1, {'@': 450}), 51: (1, {'@': 450}), 6: (1, {'@': 450}), 52: (1, {'@': 450}), 8: (1, {'@': 450}), 7: (1, {'@': 450}), 9: (1, {'@': 450}), 53: (1, {'@': 450}), 11: (1, {'@': 450}), 54: (1, {'@': 450}), 55: (1, {'@': 450}), 15: (1, {'@': 450}), 17: (1, {'@': 450}), 57: (1, {'@': 450}), 18: (1, {'@': 450}), 58: (1, {'@': 450}), 59: (1, {'@': 450}), 21: (1, {'@': 450}), 22: (1, {'@': 450}), 60: (1, {'@': 450}), 61: (1, {'@': 450}), 126: (1, {'@': 450}), 62: (1, {'@': 450}), 23: (1, {'@': 450}), 25: (1, {'@': 450}), 26: (1, {'@': 450}), 63: (1, {'@': 450}), 27: (1, {'@': 450}), 28: (1, {'@': 450}), 29: (1, {'@': 450}), 30: (1, {'@': 450}), 31: (1, {'@': 450}), 33: (1, {'@': 450}), 64: (1, {'@': 450}), 66: (1, {'@': 450}), 67: (1, {'@': 450}), 34: (1, {'@': 450}), 36: (1, {'@': 450}), 37: (1, {'@': 450}), 68: (1, {'@': 450}), 38: (1, {'@': 450}), 69: (1, {'@': 450}), 70: (1, {'@': 450}), 71: (1, {'@': 450}), 40: (1, {'@': 450}), 72: (1, {'@': 450}), 41: (1, {'@': 450}), 73: (1, {'@': 450}), 74: (1, {'@': 450}), 75: (1, {'@': 450})}, 2533: {144: (0, 2316), 145: (0, 2380)}, 2534: {43: (1, {'@': 441}), 1: (1, {'@': 441}), 2: (1, {'@': 441}), 44: (1, {'@': 441}), 45: (1, {'@': 441}), 47: (1, {'@': 441}), 48: (1, {'@': 441}), 4: (1, {'@': 441}), 49: (1, {'@': 441}), 50: (1, {'@': 441}), 51: (1, {'@': 441}), 6: (1, {'@': 441}), 52: (1, {'@': 441}), 8: (1, {'@': 441}), 7: (1, {'@': 441}), 9: (1, {'@': 441}), 53: (1, {'@': 441}), 11: (1, {'@': 441}), 54: (1, {'@': 441}), 55: (1, {'@': 441}), 15: (1, {'@': 441}), 17: (1, {'@': 441}), 57: (1, {'@': 441}), 18: (1, {'@': 441}), 58: (1, {'@': 441}), 59: (1, {'@': 441}), 21: (1, {'@': 441}), 22: (1, {'@': 441}), 60: (1, {'@': 441}), 61: (1, {'@': 441}), 126: (1, {'@': 441}), 62: (1, {'@': 441}), 23: (1, {'@': 441}), 25: (1, {'@': 441}), 26: (1, {'@': 441}), 63: (1, {'@': 441}), 27: (1, {'@': 441}), 28: (1, {'@': 441}), 29: (1, {'@': 441}), 30: (1, {'@': 441}), 31: (1, {'@': 441}), 33: (1, {'@': 441}), 64: (1, {'@': 441}), 66: (1, {'@': 441}), 67: (1, {'@': 441}), 34: (1, {'@': 441}), 36: (1, {'@': 441}), 37: (1, {'@': 441}), 68: (1, {'@': 441}), 38: (1, {'@': 441}), 69: (1, {'@': 441}), 70: (1, {'@': 441}), 71: (1, {'@': 441}), 40: (1, {'@': 441}), 72: (1, {'@': 441}), 41: (1, {'@': 441}), 73: (1, {'@': 441}), 74: (1, {'@': 441}), 75: (1, {'@': 441})}, 2535: {60: (0, 233)}, 2536: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 194: (0, 1442), 39: (0, 860), 91: (0, 863), 86: (0, 1445), 124: (0, 864)}, 2537: {43: (1, {'@': 470}), 1: (1, {'@': 470}), 2: (1, {'@': 470}), 44: (1, {'@': 470}), 45: (1, {'@': 470}), 47: (1, {'@': 470}), 48: (1, {'@': 470}), 4: (1, {'@': 470}), 49: (1, {'@': 470}), 50: (1, {'@': 470}), 51: (1, {'@': 470}), 6: (1, {'@': 470}), 52: (1, {'@': 470}), 8: (1, {'@': 470}), 7: (1, {'@': 470}), 9: (1, {'@': 470}), 53: (1, {'@': 470}), 11: (1, {'@': 470}), 54: (1, {'@': 470}), 55: (1, {'@': 470}), 15: (1, {'@': 470}), 17: (1, {'@': 470}), 57: (1, {'@': 470}), 18: (1, {'@': 470}), 58: (1, {'@': 470}), 59: (1, {'@': 470}), 21: (1, {'@': 470}), 22: (1, {'@': 470}), 60: (1, {'@': 470}), 61: (1, {'@': 470}), 126: (1, {'@': 470}), 62: (1, {'@': 470}), 23: (1, {'@': 470}), 25: (1, {'@': 470}), 26: (1, {'@': 470}), 63: (1, {'@': 470}), 27: (1, {'@': 470}), 28: (1, {'@': 470}), 29: (1, {'@': 470}), 30: (1, {'@': 470}), 31: (1, {'@': 470}), 33: (1, {'@': 470}), 64: (1, {'@': 470}), 66: (1, {'@': 470}), 67: (1, {'@': 470}), 34: (1, {'@': 470}), 36: (1, {'@': 470}), 37: (1, {'@': 470}), 68: (1, {'@': 470}), 38: (1, {'@': 470}), 69: (1, {'@': 470}), 70: (1, {'@': 470}), 71: (1, {'@': 470}), 40: (1, {'@': 470}), 72: (1, {'@': 470}), 41: (1, {'@': 470}), 73: (1, {'@': 470}), 74: (1, {'@': 470}), 75: (1, {'@': 470})}, 2538: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 86: (0, 1433), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 144: (0, 1315), 91: (0, 863), 124: (0, 864)}, 2539: {43: (1, {'@': 455}), 1: (1, {'@': 455}), 2: (1, {'@': 455}), 44: (1, {'@': 455}), 45: (1, {'@': 455}), 47: (1, {'@': 455}), 48: (1, {'@': 455}), 4: (1, {'@': 455}), 49: (1, {'@': 455}), 50: (1, {'@': 455}), 51: (1, {'@': 455}), 6: (1, {'@': 455}), 52: (1, {'@': 455}), 8: (1, {'@': 455}), 7: (1, {'@': 455}), 9: (1, {'@': 455}), 53: (1, {'@': 455}), 11: (1, {'@': 455}), 54: (1, {'@': 455}), 55: (1, {'@': 455}), 15: (1, {'@': 455}), 17: (1, {'@': 455}), 57: (1, {'@': 455}), 18: (1, {'@': 455}), 58: (1, {'@': 455}), 59: (1, {'@': 455}), 21: (1, {'@': 455}), 22: (1, {'@': 455}), 60: (1, {'@': 455}), 61: (1, {'@': 455}), 126: (1, {'@': 455}), 62: (1, {'@': 455}), 23: (1, {'@': 455}), 25: (1, {'@': 455}), 26: (1, {'@': 455}), 63: (1, {'@': 455}), 27: (1, {'@': 455}), 28: (1, {'@': 455}), 29: (1, {'@': 455}), 30: (1, {'@': 455}), 31: (1, {'@': 455}), 33: (1, {'@': 455}), 64: (1, {'@': 455}), 66: (1, {'@': 455}), 67: (1, {'@': 455}), 34: (1, {'@': 455}), 36: (1, {'@': 455}), 37: (1, {'@': 455}), 68: (1, {'@': 455}), 38: (1, {'@': 455}), 69: (1, {'@': 455}), 70: (1, {'@': 455}), 71: (1, {'@': 455}), 40: (1, {'@': 455}), 72: (1, {'@': 455}), 41: (1, {'@': 455}), 73: (1, {'@': 455}), 74: (1, {'@': 455}), 75: (1, {'@': 455})}, 2540: {112: (0, 236)}, 2541: {43: (1, {'@': 466}), 1: (1, {'@': 466}), 2: (1, {'@': 466}), 44: (1, {'@': 466}), 45: (1, {'@': 466}), 47: (1, {'@': 466}), 48: (1, {'@': 466}), 4: (1, {'@': 466}), 49: (1, {'@': 466}), 50: (1, {'@': 466}), 51: (1, {'@': 466}), 6: (1, {'@': 466}), 52: (1, {'@': 466}), 8: (1, {'@': 466}), 7: (1, {'@': 466}), 9: (1, {'@': 466}), 53: (1, {'@': 466}), 11: (1, {'@': 466}), 54: (1, {'@': 466}), 55: (1, {'@': 466}), 15: (1, {'@': 466}), 17: (1, {'@': 466}), 57: (1, {'@': 466}), 18: (1, {'@': 466}), 58: (1, {'@': 466}), 59: (1, {'@': 466}), 21: (1, {'@': 466}), 22: (1, {'@': 466}), 60: (1, {'@': 466}), 61: (1, {'@': 466}), 126: (1, {'@': 466}), 62: (1, {'@': 466}), 23: (1, {'@': 466}), 25: (1, {'@': 466}), 26: (1, {'@': 466}), 63: (1, {'@': 466}), 27: (1, {'@': 466}), 28: (1, {'@': 466}), 29: (1, {'@': 466}), 30: (1, {'@': 466}), 31: (1, {'@': 466}), 33: (1, {'@': 466}), 64: (1, {'@': 466}), 66: (1, {'@': 466}), 67: (1, {'@': 466}), 34: (1, {'@': 466}), 36: (1, {'@': 466}), 37: (1, {'@': 466}), 68: (1, {'@': 466}), 38: (1, {'@': 466}), 69: (1, {'@': 466}), 70: (1, {'@': 466}), 71: (1, {'@': 466}), 40: (1, {'@': 466}), 72: (1, {'@': 466}), 41: (1, {'@': 466}), 73: (1, {'@': 466}), 74: (1, {'@': 466}), 75: (1, {'@': 466})}, 2542: {144: (0, 2316), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 86: (0, 1448), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 145: (0, 1451), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2543: {43: (1, {'@': 460}), 1: (1, {'@': 460}), 2: (1, {'@': 460}), 44: (1, {'@': 460}), 45: (1, {'@': 460}), 47: (1, {'@': 460}), 48: (1, {'@': 460}), 4: (1, {'@': 460}), 49: (1, {'@': 460}), 50: (1, {'@': 460}), 51: (1, {'@': 460}), 6: (1, {'@': 460}), 52: (1, {'@': 460}), 8: (1, {'@': 460}), 7: (1, {'@': 460}), 9: (1, {'@': 460}), 53: (1, {'@': 460}), 11: (1, {'@': 460}), 54: (1, {'@': 460}), 55: (1, {'@': 460}), 15: (1, {'@': 460}), 17: (1, {'@': 460}), 57: (1, {'@': 460}), 18: (1, {'@': 460}), 58: (1, {'@': 460}), 59: (1, {'@': 460}), 21: (1, {'@': 460}), 22: (1, {'@': 460}), 60: (1, {'@': 460}), 61: (1, {'@': 460}), 126: (1, {'@': 460}), 62: (1, {'@': 460}), 23: (1, {'@': 460}), 25: (1, {'@': 460}), 26: (1, {'@': 460}), 63: (1, {'@': 460}), 27: (1, {'@': 460}), 28: (1, {'@': 460}), 29: (1, {'@': 460}), 30: (1, {'@': 460}), 31: (1, {'@': 460}), 33: (1, {'@': 460}), 64: (1, {'@': 460}), 66: (1, {'@': 460}), 67: (1, {'@': 460}), 34: (1, {'@': 460}), 36: (1, {'@': 460}), 37: (1, {'@': 460}), 68: (1, {'@': 460}), 38: (1, {'@': 460}), 69: (1, {'@': 460}), 70: (1, {'@': 460}), 71: (1, {'@': 460}), 40: (1, {'@': 460}), 72: (1, {'@': 460}), 41: (1, {'@': 460}), 73: (1, {'@': 460}), 74: (1, {'@': 460}), 75: (1, {'@': 460})}, 2544: {146: (0, 217)}, 2545: {43: (1, {'@': 479}), 1: (1, {'@': 479}), 2: (1, {'@': 479}), 44: (1, {'@': 479}), 45: (1, {'@': 479}), 47: (1, {'@': 479}), 48: (1, {'@': 479}), 4: (1, {'@': 479}), 49: (1, {'@': 479}), 50: (1, {'@': 479}), 51: (1, {'@': 479}), 6: (1, {'@': 479}), 52: (1, {'@': 479}), 8: (1, {'@': 479}), 7: (1, {'@': 479}), 9: (1, {'@': 479}), 53: (1, {'@': 479}), 11: (1, {'@': 479}), 54: (1, {'@': 479}), 55: (1, {'@': 479}), 15: (1, {'@': 479}), 17: (1, {'@': 479}), 57: (1, {'@': 479}), 18: (1, {'@': 479}), 58: (1, {'@': 479}), 59: (1, {'@': 479}), 21: (1, {'@': 479}), 22: (1, {'@': 479}), 60: (1, {'@': 479}), 61: (1, {'@': 479}), 126: (1, {'@': 479}), 62: (1, {'@': 479}), 23: (1, {'@': 479}), 25: (1, {'@': 479}), 26: (1, {'@': 479}), 63: (1, {'@': 479}), 27: (1, {'@': 479}), 28: (1, {'@': 479}), 29: (1, {'@': 479}), 30: (1, {'@': 479}), 31: (1, {'@': 479}), 33: (1, {'@': 479}), 64: (1, {'@': 479}), 66: (1, {'@': 479}), 67: (1, {'@': 479}), 34: (1, {'@': 479}), 36: (1, {'@': 479}), 37: (1, {'@': 479}), 68: (1, {'@': 479}), 38: (1, {'@': 479}), 69: (1, {'@': 479}), 70: (1, {'@': 479}), 71: (1, {'@': 479}), 40: (1, {'@': 479}), 72: (1, {'@': 479}), 41: (1, {'@': 479}), 73: (1, {'@': 479}), 74: (1, {'@': 479}), 75: (1, {'@': 479})}, 2546: {43: (1, {'@': 439}), 1: (1, {'@': 439}), 2: (1, {'@': 439}), 44: (1, {'@': 439}), 45: (1, {'@': 439}), 47: (1, {'@': 439}), 48: (1, {'@': 439}), 4: (1, {'@': 439}), 49: (1, {'@': 439}), 50: (1, {'@': 439}), 51: (1, {'@': 439}), 6: (1, {'@': 439}), 52: (1, {'@': 439}), 8: (1, {'@': 439}), 7: (1, {'@': 439}), 9: (1, {'@': 439}), 53: (1, {'@': 439}), 11: (1, {'@': 439}), 54: (1, {'@': 439}), 55: (1, {'@': 439}), 15: (1, {'@': 439}), 17: (1, {'@': 439}), 57: (1, {'@': 439}), 18: (1, {'@': 439}), 58: (1, {'@': 439}), 59: (1, {'@': 439}), 21: (1, {'@': 439}), 22: (1, {'@': 439}), 60: (1, {'@': 439}), 61: (1, {'@': 439}), 126: (1, {'@': 439}), 62: (1, {'@': 439}), 23: (1, {'@': 439}), 25: (1, {'@': 439}), 26: (1, {'@': 439}), 63: (1, {'@': 439}), 27: (1, {'@': 439}), 28: (1, {'@': 439}), 29: (1, {'@': 439}), 30: (1, {'@': 439}), 31: (1, {'@': 439}), 33: (1, {'@': 439}), 64: (1, {'@': 439}), 66: (1, {'@': 439}), 67: (1, {'@': 439}), 34: (1, {'@': 439}), 36: (1, {'@': 439}), 37: (1, {'@': 439}), 68: (1, {'@': 439}), 38: (1, {'@': 439}), 69: (1, {'@': 439}), 70: (1, {'@': 439}), 71: (1, {'@': 439}), 40: (1, {'@': 439}), 72: (1, {'@': 439}), 41: (1, {'@': 439}), 73: (1, {'@': 439}), 74: (1, {'@': 439}), 75: (1, {'@': 439})}, 2547: {144: (0, 2316), 145: (0, 2469)}, 2548: {126: (1, {'@': 1227}), 146: (1, {'@': 1227})}, 2549: {144: (0, 2316), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 145: (0, 2417), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 86: (0, 2429), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2550: {43: (1, {'@': 461}), 1: (1, {'@': 461}), 2: (1, {'@': 461}), 44: (1, {'@': 461}), 45: (1, {'@': 461}), 47: (1, {'@': 461}), 48: (1, {'@': 461}), 4: (1, {'@': 461}), 49: (1, {'@': 461}), 50: (1, {'@': 461}), 51: (1, {'@': 461}), 6: (1, {'@': 461}), 52: (1, {'@': 461}), 8: (1, {'@': 461}), 7: (1, {'@': 461}), 9: (1, {'@': 461}), 53: (1, {'@': 461}), 11: (1, {'@': 461}), 54: (1, {'@': 461}), 55: (1, {'@': 461}), 15: (1, {'@': 461}), 17: (1, {'@': 461}), 57: (1, {'@': 461}), 18: (1, {'@': 461}), 58: (1, {'@': 461}), 59: (1, {'@': 461}), 21: (1, {'@': 461}), 22: (1, {'@': 461}), 60: (1, {'@': 461}), 61: (1, {'@': 461}), 126: (1, {'@': 461}), 62: (1, {'@': 461}), 23: (1, {'@': 461}), 25: (1, {'@': 461}), 26: (1, {'@': 461}), 63: (1, {'@': 461}), 27: (1, {'@': 461}), 28: (1, {'@': 461}), 29: (1, {'@': 461}), 30: (1, {'@': 461}), 31: (1, {'@': 461}), 33: (1, {'@': 461}), 64: (1, {'@': 461}), 66: (1, {'@': 461}), 67: (1, {'@': 461}), 34: (1, {'@': 461}), 36: (1, {'@': 461}), 37: (1, {'@': 461}), 68: (1, {'@': 461}), 38: (1, {'@': 461}), 69: (1, {'@': 461}), 70: (1, {'@': 461}), 71: (1, {'@': 461}), 40: (1, {'@': 461}), 72: (1, {'@': 461}), 41: (1, {'@': 461}), 73: (1, {'@': 461}), 74: (1, {'@': 461}), 75: (1, {'@': 461})}, 2551: {43: (1, {'@': 456}), 1: (1, {'@': 456}), 2: (1, {'@': 456}), 44: (1, {'@': 456}), 45: (1, {'@': 456}), 47: (1, {'@': 456}), 48: (1, {'@': 456}), 4: (1, {'@': 456}), 49: (1, {'@': 456}), 50: (1, {'@': 456}), 51: (1, {'@': 456}), 6: (1, {'@': 456}), 52: (1, {'@': 456}), 8: (1, {'@': 456}), 7: (1, {'@': 456}), 9: (1, {'@': 456}), 53: (1, {'@': 456}), 11: (1, {'@': 456}), 54: (1, {'@': 456}), 55: (1, {'@': 456}), 15: (1, {'@': 456}), 17: (1, {'@': 456}), 57: (1, {'@': 456}), 18: (1, {'@': 456}), 58: (1, {'@': 456}), 59: (1, {'@': 456}), 21: (1, {'@': 456}), 22: (1, {'@': 456}), 60: (1, {'@': 456}), 61: (1, {'@': 456}), 126: (1, {'@': 456}), 62: (1, {'@': 456}), 23: (1, {'@': 456}), 25: (1, {'@': 456}), 26: (1, {'@': 456}), 63: (1, {'@': 456}), 27: (1, {'@': 456}), 28: (1, {'@': 456}), 29: (1, {'@': 456}), 30: (1, {'@': 456}), 31: (1, {'@': 456}), 33: (1, {'@': 456}), 64: (1, {'@': 456}), 66: (1, {'@': 456}), 67: (1, {'@': 456}), 34: (1, {'@': 456}), 36: (1, {'@': 456}), 37: (1, {'@': 456}), 68: (1, {'@': 456}), 38: (1, {'@': 456}), 69: (1, {'@': 456}), 70: (1, {'@': 456}), 71: (1, {'@': 456}), 40: (1, {'@': 456}), 72: (1, {'@': 456}), 41: (1, {'@': 456}), 73: (1, {'@': 456}), 74: (1, {'@': 456}), 75: (1, {'@': 456})}, 2552: {112: (0, 203)}, 2553: {43: (1, {'@': 491}), 1: (1, {'@': 491}), 2: (1, {'@': 491}), 44: (1, {'@': 491}), 45: (1, {'@': 491}), 47: (1, {'@': 491}), 48: (1, {'@': 491}), 4: (1, {'@': 491}), 49: (1, {'@': 491}), 50: (1, {'@': 491}), 51: (1, {'@': 491}), 6: (1, {'@': 491}), 52: (1, {'@': 491}), 8: (1, {'@': 491}), 7: (1, {'@': 491}), 9: (1, {'@': 491}), 53: (1, {'@': 491}), 11: (1, {'@': 491}), 54: (1, {'@': 491}), 55: (1, {'@': 491}), 15: (1, {'@': 491}), 17: (1, {'@': 491}), 57: (1, {'@': 491}), 18: (1, {'@': 491}), 58: (1, {'@': 491}), 59: (1, {'@': 491}), 21: (1, {'@': 491}), 22: (1, {'@': 491}), 60: (1, {'@': 491}), 61: (1, {'@': 491}), 126: (1, {'@': 491}), 62: (1, {'@': 491}), 23: (1, {'@': 491}), 25: (1, {'@': 491}), 26: (1, {'@': 491}), 63: (1, {'@': 491}), 27: (1, {'@': 491}), 28: (1, {'@': 491}), 29: (1, {'@': 491}), 30: (1, {'@': 491}), 31: (1, {'@': 491}), 33: (1, {'@': 491}), 64: (1, {'@': 491}), 66: (1, {'@': 491}), 67: (1, {'@': 491}), 34: (1, {'@': 491}), 36: (1, {'@': 491}), 37: (1, {'@': 491}), 68: (1, {'@': 491}), 38: (1, {'@': 491}), 69: (1, {'@': 491}), 70: (1, {'@': 491}), 71: (1, {'@': 491}), 40: (1, {'@': 491}), 72: (1, {'@': 491}), 41: (1, {'@': 491}), 73: (1, {'@': 491}), 74: (1, {'@': 491}), 75: (1, {'@': 491})}, 2554: {43: (1, {'@': 492}), 1: (1, {'@': 492}), 2: (1, {'@': 492}), 44: (1, {'@': 492}), 45: (1, {'@': 492}), 47: (1, {'@': 492}), 48: (1, {'@': 492}), 4: (1, {'@': 492}), 49: (1, {'@': 492}), 50: (1, {'@': 492}), 51: (1, {'@': 492}), 6: (1, {'@': 492}), 52: (1, {'@': 492}), 8: (1, {'@': 492}), 7: (1, {'@': 492}), 9: (1, {'@': 492}), 53: (1, {'@': 492}), 11: (1, {'@': 492}), 54: (1, {'@': 492}), 55: (1, {'@': 492}), 15: (1, {'@': 492}), 17: (1, {'@': 492}), 57: (1, {'@': 492}), 18: (1, {'@': 492}), 58: (1, {'@': 492}), 59: (1, {'@': 492}), 21: (1, {'@': 492}), 22: (1, {'@': 492}), 60: (1, {'@': 492}), 61: (1, {'@': 492}), 126: (1, {'@': 492}), 62: (1, {'@': 492}), 23: (1, {'@': 492}), 25: (1, {'@': 492}), 26: (1, {'@': 492}), 63: (1, {'@': 492}), 27: (1, {'@': 492}), 28: (1, {'@': 492}), 29: (1, {'@': 492}), 30: (1, {'@': 492}), 31: (1, {'@': 492}), 33: (1, {'@': 492}), 64: (1, {'@': 492}), 66: (1, {'@': 492}), 67: (1, {'@': 492}), 34: (1, {'@': 492}), 36: (1, {'@': 492}), 37: (1, {'@': 492}), 68: (1, {'@': 492}), 38: (1, {'@': 492}), 69: (1, {'@': 492}), 70: (1, {'@': 492}), 71: (1, {'@': 492}), 40: (1, {'@': 492}), 72: (1, {'@': 492}), 41: (1, {'@': 492}), 73: (1, {'@': 492}), 74: (1, {'@': 492}), 75: (1, {'@': 492})}, 2555: {708: (0, 243), 126: (0, 245), 146: (1, {'@': 1222})}, 2556: {43: (1, {'@': 493}), 1: (1, {'@': 493}), 2: (1, {'@': 493}), 44: (1, {'@': 493}), 45: (1, {'@': 493}), 47: (1, {'@': 493}), 48: (1, {'@': 493}), 4: (1, {'@': 493}), 49: (1, {'@': 493}), 50: (1, {'@': 493}), 51: (1, {'@': 493}), 6: (1, {'@': 493}), 52: (1, {'@': 493}), 8: (1, {'@': 493}), 7: (1, {'@': 493}), 9: (1, {'@': 493}), 53: (1, {'@': 493}), 11: (1, {'@': 493}), 54: (1, {'@': 493}), 55: (1, {'@': 493}), 15: (1, {'@': 493}), 17: (1, {'@': 493}), 57: (1, {'@': 493}), 18: (1, {'@': 493}), 58: (1, {'@': 493}), 59: (1, {'@': 493}), 21: (1, {'@': 493}), 22: (1, {'@': 493}), 60: (1, {'@': 493}), 61: (1, {'@': 493}), 126: (1, {'@': 493}), 62: (1, {'@': 493}), 23: (1, {'@': 493}), 25: (1, {'@': 493}), 26: (1, {'@': 493}), 63: (1, {'@': 493}), 27: (1, {'@': 493}), 28: (1, {'@': 493}), 29: (1, {'@': 493}), 30: (1, {'@': 493}), 31: (1, {'@': 493}), 33: (1, {'@': 493}), 64: (1, {'@': 493}), 66: (1, {'@': 493}), 67: (1, {'@': 493}), 34: (1, {'@': 493}), 36: (1, {'@': 493}), 37: (1, {'@': 493}), 68: (1, {'@': 493}), 38: (1, {'@': 493}), 69: (1, {'@': 493}), 70: (1, {'@': 493}), 71: (1, {'@': 493}), 40: (1, {'@': 493}), 72: (1, {'@': 493}), 41: (1, {'@': 493}), 73: (1, {'@': 493}), 74: (1, {'@': 493}), 75: (1, {'@': 493})}, 2557: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 124: (0, 864), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 194: (0, 2326), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 86: (0, 2328)}, 2558: {43: (1, {'@': 458}), 1: (1, {'@': 458}), 2: (1, {'@': 458}), 44: (1, {'@': 458}), 45: (1, {'@': 458}), 47: (1, {'@': 458}), 48: (1, {'@': 458}), 4: (1, {'@': 458}), 49: (1, {'@': 458}), 50: (1, {'@': 458}), 51: (1, {'@': 458}), 6: (1, {'@': 458}), 52: (1, {'@': 458}), 8: (1, {'@': 458}), 7: (1, {'@': 458}), 9: (1, {'@': 458}), 53: (1, {'@': 458}), 11: (1, {'@': 458}), 54: (1, {'@': 458}), 55: (1, {'@': 458}), 15: (1, {'@': 458}), 17: (1, {'@': 458}), 57: (1, {'@': 458}), 18: (1, {'@': 458}), 58: (1, {'@': 458}), 59: (1, {'@': 458}), 21: (1, {'@': 458}), 22: (1, {'@': 458}), 60: (1, {'@': 458}), 61: (1, {'@': 458}), 126: (1, {'@': 458}), 62: (1, {'@': 458}), 23: (1, {'@': 458}), 25: (1, {'@': 458}), 26: (1, {'@': 458}), 63: (1, {'@': 458}), 27: (1, {'@': 458}), 28: (1, {'@': 458}), 29: (1, {'@': 458}), 30: (1, {'@': 458}), 31: (1, {'@': 458}), 33: (1, {'@': 458}), 64: (1, {'@': 458}), 66: (1, {'@': 458}), 67: (1, {'@': 458}), 34: (1, {'@': 458}), 36: (1, {'@': 458}), 37: (1, {'@': 458}), 68: (1, {'@': 458}), 38: (1, {'@': 458}), 69: (1, {'@': 458}), 70: (1, {'@': 458}), 71: (1, {'@': 458}), 40: (1, {'@': 458}), 72: (1, {'@': 458}), 41: (1, {'@': 458}), 73: (1, {'@': 458}), 74: (1, {'@': 458}), 75: (1, {'@': 458})}, 2559: {144: (0, 2316), 145: (0, 766)}, 2560: {43: (1, {'@': 474}), 1: (1, {'@': 474}), 2: (1, {'@': 474}), 44: (1, {'@': 474}), 45: (1, {'@': 474}), 47: (1, {'@': 474}), 48: (1, {'@': 474}), 4: (1, {'@': 474}), 49: (1, {'@': 474}), 50: (1, {'@': 474}), 51: (1, {'@': 474}), 6: (1, {'@': 474}), 52: (1, {'@': 474}), 8: (1, {'@': 474}), 7: (1, {'@': 474}), 9: (1, {'@': 474}), 53: (1, {'@': 474}), 11: (1, {'@': 474}), 54: (1, {'@': 474}), 55: (1, {'@': 474}), 15: (1, {'@': 474}), 17: (1, {'@': 474}), 57: (1, {'@': 474}), 18: (1, {'@': 474}), 58: (1, {'@': 474}), 59: (1, {'@': 474}), 21: (1, {'@': 474}), 22: (1, {'@': 474}), 60: (1, {'@': 474}), 61: (1, {'@': 474}), 126: (1, {'@': 474}), 62: (1, {'@': 474}), 23: (1, {'@': 474}), 25: (1, {'@': 474}), 26: (1, {'@': 474}), 63: (1, {'@': 474}), 27: (1, {'@': 474}), 28: (1, {'@': 474}), 29: (1, {'@': 474}), 30: (1, {'@': 474}), 31: (1, {'@': 474}), 33: (1, {'@': 474}), 64: (1, {'@': 474}), 66: (1, {'@': 474}), 67: (1, {'@': 474}), 34: (1, {'@': 474}), 36: (1, {'@': 474}), 37: (1, {'@': 474}), 68: (1, {'@': 474}), 38: (1, {'@': 474}), 69: (1, {'@': 474}), 70: (1, {'@': 474}), 71: (1, {'@': 474}), 40: (1, {'@': 474}), 72: (1, {'@': 474}), 41: (1, {'@': 474}), 73: (1, {'@': 474}), 74: (1, {'@': 474}), 75: (1, {'@': 474})}, 2561: {43: (1, {'@': 447}), 1: (1, {'@': 447}), 2: (1, {'@': 447}), 44: (1, {'@': 447}), 45: (1, {'@': 447}), 47: (1, {'@': 447}), 48: (1, {'@': 447}), 4: (1, {'@': 447}), 49: (1, {'@': 447}), 50: (1, {'@': 447}), 51: (1, {'@': 447}), 6: (1, {'@': 447}), 52: (1, {'@': 447}), 8: (1, {'@': 447}), 7: (1, {'@': 447}), 9: (1, {'@': 447}), 53: (1, {'@': 447}), 11: (1, {'@': 447}), 54: (1, {'@': 447}), 55: (1, {'@': 447}), 15: (1, {'@': 447}), 17: (1, {'@': 447}), 57: (1, {'@': 447}), 18: (1, {'@': 447}), 58: (1, {'@': 447}), 59: (1, {'@': 447}), 21: (1, {'@': 447}), 22: (1, {'@': 447}), 60: (1, {'@': 447}), 61: (1, {'@': 447}), 126: (1, {'@': 447}), 62: (1, {'@': 447}), 23: (1, {'@': 447}), 25: (1, {'@': 447}), 26: (1, {'@': 447}), 63: (1, {'@': 447}), 27: (1, {'@': 447}), 28: (1, {'@': 447}), 29: (1, {'@': 447}), 30: (1, {'@': 447}), 31: (1, {'@': 447}), 33: (1, {'@': 447}), 64: (1, {'@': 447}), 66: (1, {'@': 447}), 67: (1, {'@': 447}), 34: (1, {'@': 447}), 36: (1, {'@': 447}), 37: (1, {'@': 447}), 68: (1, {'@': 447}), 38: (1, {'@': 447}), 69: (1, {'@': 447}), 70: (1, {'@': 447}), 71: (1, {'@': 447}), 40: (1, {'@': 447}), 72: (1, {'@': 447}), 41: (1, {'@': 447}), 73: (1, {'@': 447}), 74: (1, {'@': 447}), 75: (1, {'@': 447})}, 2562: {126: (1, {'@': 1223}), 146: (1, {'@': 1223})}, 2563: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 86: (0, 1447), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 600: (0, 2300), 599: (0, 2304), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 709: (0, 2307), 590: (0, 2311), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 42: (0, 858), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 598: (0, 2313), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2564: {43: (1, {'@': 459}), 1: (1, {'@': 459}), 2: (1, {'@': 459}), 44: (1, {'@': 459}), 45: (1, {'@': 459}), 47: (1, {'@': 459}), 48: (1, {'@': 459}), 4: (1, {'@': 459}), 49: (1, {'@': 459}), 50: (1, {'@': 459}), 51: (1, {'@': 459}), 6: (1, {'@': 459}), 52: (1, {'@': 459}), 8: (1, {'@': 459}), 7: (1, {'@': 459}), 9: (1, {'@': 459}), 53: (1, {'@': 459}), 11: (1, {'@': 459}), 54: (1, {'@': 459}), 55: (1, {'@': 459}), 15: (1, {'@': 459}), 17: (1, {'@': 459}), 57: (1, {'@': 459}), 18: (1, {'@': 459}), 58: (1, {'@': 459}), 59: (1, {'@': 459}), 21: (1, {'@': 459}), 22: (1, {'@': 459}), 60: (1, {'@': 459}), 61: (1, {'@': 459}), 126: (1, {'@': 459}), 62: (1, {'@': 459}), 23: (1, {'@': 459}), 25: (1, {'@': 459}), 26: (1, {'@': 459}), 63: (1, {'@': 459}), 27: (1, {'@': 459}), 28: (1, {'@': 459}), 29: (1, {'@': 459}), 30: (1, {'@': 459}), 31: (1, {'@': 459}), 33: (1, {'@': 459}), 64: (1, {'@': 459}), 66: (1, {'@': 459}), 67: (1, {'@': 459}), 34: (1, {'@': 459}), 36: (1, {'@': 459}), 37: (1, {'@': 459}), 68: (1, {'@': 459}), 38: (1, {'@': 459}), 69: (1, {'@': 459}), 70: (1, {'@': 459}), 71: (1, {'@': 459}), 40: (1, {'@': 459}), 72: (1, {'@': 459}), 41: (1, {'@': 459}), 73: (1, {'@': 459}), 74: (1, {'@': 459}), 75: (1, {'@': 459})}, 2565: {112: (0, 239)}, 2566: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 86: (0, 2397), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864), 194: (0, 2400)}, 2567: {43: (1, {'@': 480}), 1: (1, {'@': 480}), 2: (1, {'@': 480}), 44: (1, {'@': 480}), 45: (1, {'@': 480}), 47: (1, {'@': 480}), 48: (1, {'@': 480}), 4: (1, {'@': 480}), 49: (1, {'@': 480}), 50: (1, {'@': 480}), 51: (1, {'@': 480}), 6: (1, {'@': 480}), 52: (1, {'@': 480}), 8: (1, {'@': 480}), 7: (1, {'@': 480}), 9: (1, {'@': 480}), 53: (1, {'@': 480}), 11: (1, {'@': 480}), 54: (1, {'@': 480}), 55: (1, {'@': 480}), 15: (1, {'@': 480}), 17: (1, {'@': 480}), 57: (1, {'@': 480}), 18: (1, {'@': 480}), 58: (1, {'@': 480}), 59: (1, {'@': 480}), 21: (1, {'@': 480}), 22: (1, {'@': 480}), 60: (1, {'@': 480}), 61: (1, {'@': 480}), 126: (1, {'@': 480}), 62: (1, {'@': 480}), 23: (1, {'@': 480}), 25: (1, {'@': 480}), 26: (1, {'@': 480}), 63: (1, {'@': 480}), 27: (1, {'@': 480}), 28: (1, {'@': 480}), 29: (1, {'@': 480}), 30: (1, {'@': 480}), 31: (1, {'@': 480}), 33: (1, {'@': 480}), 64: (1, {'@': 480}), 66: (1, {'@': 480}), 67: (1, {'@': 480}), 34: (1, {'@': 480}), 36: (1, {'@': 480}), 37: (1, {'@': 480}), 68: (1, {'@': 480}), 38: (1, {'@': 480}), 69: (1, {'@': 480}), 70: (1, {'@': 480}), 71: (1, {'@': 480}), 40: (1, {'@': 480}), 72: (1, {'@': 480}), 41: (1, {'@': 480}), 73: (1, {'@': 480}), 74: (1, {'@': 480}), 75: (1, {'@': 480})}, 2568: {43: (1, {'@': 457}), 1: (1, {'@': 457}), 2: (1, {'@': 457}), 44: (1, {'@': 457}), 45: (1, {'@': 457}), 47: (1, {'@': 457}), 48: (1, {'@': 457}), 4: (1, {'@': 457}), 49: (1, {'@': 457}), 50: (1, {'@': 457}), 51: (1, {'@': 457}), 6: (1, {'@': 457}), 52: (1, {'@': 457}), 8: (1, {'@': 457}), 7: (1, {'@': 457}), 9: (1, {'@': 457}), 53: (1, {'@': 457}), 11: (1, {'@': 457}), 54: (1, {'@': 457}), 55: (1, {'@': 457}), 15: (1, {'@': 457}), 17: (1, {'@': 457}), 57: (1, {'@': 457}), 18: (1, {'@': 457}), 58: (1, {'@': 457}), 59: (1, {'@': 457}), 21: (1, {'@': 457}), 22: (1, {'@': 457}), 60: (1, {'@': 457}), 61: (1, {'@': 457}), 126: (1, {'@': 457}), 62: (1, {'@': 457}), 23: (1, {'@': 457}), 25: (1, {'@': 457}), 26: (1, {'@': 457}), 63: (1, {'@': 457}), 27: (1, {'@': 457}), 28: (1, {'@': 457}), 29: (1, {'@': 457}), 30: (1, {'@': 457}), 31: (1, {'@': 457}), 33: (1, {'@': 457}), 64: (1, {'@': 457}), 66: (1, {'@': 457}), 67: (1, {'@': 457}), 34: (1, {'@': 457}), 36: (1, {'@': 457}), 37: (1, {'@': 457}), 68: (1, {'@': 457}), 38: (1, {'@': 457}), 69: (1, {'@': 457}), 70: (1, {'@': 457}), 71: (1, {'@': 457}), 40: (1, {'@': 457}), 72: (1, {'@': 457}), 41: (1, {'@': 457}), 73: (1, {'@': 457}), 74: (1, {'@': 457}), 75: (1, {'@': 457})}, 2569: {126: (1, {'@': 1228}), 146: (1, {'@': 1228})}, 2570: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 81: (0, 2295), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 91: (0, 863), 86: (0, 2320), 96: (0, 789), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 89: (0, 2384), 85: (0, 816), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 100: (0, 817), 10: (0, 826), 194: (0, 2323), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 124: (0, 864)}, 2571: {43: (1, {'@': 449}), 1: (1, {'@': 449}), 2: (1, {'@': 449}), 44: (1, {'@': 449}), 45: (1, {'@': 449}), 47: (1, {'@': 449}), 48: (1, {'@': 449}), 4: (1, {'@': 449}), 49: (1, {'@': 449}), 50: (1, {'@': 449}), 51: (1, {'@': 449}), 6: (1, {'@': 449}), 52: (1, {'@': 449}), 8: (1, {'@': 449}), 7: (1, {'@': 449}), 9: (1, {'@': 449}), 53: (1, {'@': 449}), 11: (1, {'@': 449}), 54: (1, {'@': 449}), 55: (1, {'@': 449}), 15: (1, {'@': 449}), 17: (1, {'@': 449}), 57: (1, {'@': 449}), 18: (1, {'@': 449}), 58: (1, {'@': 449}), 59: (1, {'@': 449}), 21: (1, {'@': 449}), 22: (1, {'@': 449}), 60: (1, {'@': 449}), 61: (1, {'@': 449}), 126: (1, {'@': 449}), 62: (1, {'@': 449}), 23: (1, {'@': 449}), 25: (1, {'@': 449}), 26: (1, {'@': 449}), 63: (1, {'@': 449}), 27: (1, {'@': 449}), 28: (1, {'@': 449}), 29: (1, {'@': 449}), 30: (1, {'@': 449}), 31: (1, {'@': 449}), 33: (1, {'@': 449}), 64: (1, {'@': 449}), 66: (1, {'@': 449}), 67: (1, {'@': 449}), 34: (1, {'@': 449}), 36: (1, {'@': 449}), 37: (1, {'@': 449}), 68: (1, {'@': 449}), 38: (1, {'@': 449}), 69: (1, {'@': 449}), 70: (1, {'@': 449}), 71: (1, {'@': 449}), 40: (1, {'@': 449}), 72: (1, {'@': 449}), 41: (1, {'@': 449}), 73: (1, {'@': 449}), 74: (1, {'@': 449}), 75: (1, {'@': 449})}, 2572: {43: (1, {'@': 445}), 1: (1, {'@': 445}), 2: (1, {'@': 445}), 44: (1, {'@': 445}), 45: (1, {'@': 445}), 47: (1, {'@': 445}), 48: (1, {'@': 445}), 4: (1, {'@': 445}), 49: (1, {'@': 445}), 50: (1, {'@': 445}), 51: (1, {'@': 445}), 6: (1, {'@': 445}), 52: (1, {'@': 445}), 8: (1, {'@': 445}), 7: (1, {'@': 445}), 9: (1, {'@': 445}), 53: (1, {'@': 445}), 11: (1, {'@': 445}), 54: (1, {'@': 445}), 55: (1, {'@': 445}), 15: (1, {'@': 445}), 17: (1, {'@': 445}), 57: (1, {'@': 445}), 18: (1, {'@': 445}), 58: (1, {'@': 445}), 59: (1, {'@': 445}), 21: (1, {'@': 445}), 22: (1, {'@': 445}), 60: (1, {'@': 445}), 61: (1, {'@': 445}), 126: (1, {'@': 445}), 62: (1, {'@': 445}), 23: (1, {'@': 445}), 25: (1, {'@': 445}), 26: (1, {'@': 445}), 63: (1, {'@': 445}), 27: (1, {'@': 445}), 28: (1, {'@': 445}), 29: (1, {'@': 445}), 30: (1, {'@': 445}), 31: (1, {'@': 445}), 33: (1, {'@': 445}), 64: (1, {'@': 445}), 66: (1, {'@': 445}), 67: (1, {'@': 445}), 34: (1, {'@': 445}), 36: (1, {'@': 445}), 37: (1, {'@': 445}), 68: (1, {'@': 445}), 38: (1, {'@': 445}), 69: (1, {'@': 445}), 70: (1, {'@': 445}), 71: (1, {'@': 445}), 40: (1, {'@': 445}), 72: (1, {'@': 445}), 41: (1, {'@': 445}), 73: (1, {'@': 445}), 74: (1, {'@': 445}), 75: (1, {'@': 445})}, 2573: {112: (0, 225)}, 2574: {490: (0, 2317), 77: (0, 17), 78: (0, 1960), 79: (0, 1973), 494: (0, 2334), 12: (0, 396), 459: (0, 216), 491: (0, 2336), 82: (0, 791), 83: (0, 809), 84: (0, 811), 85: (0, 816), 10: (0, 826), 87: (0, 842), 35: (0, 844), 88: (0, 848), 90: (0, 853), 144: (0, 221), 91: (0, 863), 456: (0, 212), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 56: (0, 783), 458: (0, 215), 95: (0, 786), 96: (0, 789), 98: (0, 793), 19: (0, 800), 13: (0, 802), 463: (0, 224), 32: (0, 807), 99: (0, 812), 100: (0, 817), 20: (0, 822), 102: (0, 823), 103: (0, 825), 462: (0, 223), 105: (0, 830), 65: (0, 834), 454: (0, 188), 106: (0, 838), 108: (0, 400), 109: (0, 390), 46: (0, 781), 110: (0, 799), 86: (0, 2341), 111: (0, 821), 14: (0, 399), 496: (0, 2343), 113: (0, 828), 114: (0, 832), 455: (0, 210), 0: (0, 846), 42: (0, 858), 39: (0, 860), 115: (0, 44), 461: (0, 219), 492: (0, 2347), 710: (0, 2350), 116: (0, 780), 493: (0, 2351), 5: (0, 787), 117: (0, 804), 24: (0, 814), 495: (0, 2354), 118: (0, 819), 119: (0, 836), 120: (0, 840), 457: (0, 213), 122: (0, 850), 460: (0, 2356), 3: (0, 855), 123: (0, 856), 124: (0, 864)}, 2575: {43: (1, {'@': 482}), 1: (1, {'@': 482}), 2: (1, {'@': 482}), 44: (1, {'@': 482}), 45: (1, {'@': 482}), 47: (1, {'@': 482}), 48: (1, {'@': 482}), 4: (1, {'@': 482}), 49: (1, {'@': 482}), 50: (1, {'@': 482}), 51: (1, {'@': 482}), 6: (1, {'@': 482}), 52: (1, {'@': 482}), 8: (1, {'@': 482}), 7: (1, {'@': 482}), 9: (1, {'@': 482}), 53: (1, {'@': 482}), 11: (1, {'@': 482}), 54: (1, {'@': 482}), 55: (1, {'@': 482}), 15: (1, {'@': 482}), 17: (1, {'@': 482}), 57: (1, {'@': 482}), 18: (1, {'@': 482}), 58: (1, {'@': 482}), 59: (1, {'@': 482}), 21: (1, {'@': 482}), 22: (1, {'@': 482}), 60: (1, {'@': 482}), 61: (1, {'@': 482}), 126: (1, {'@': 482}), 62: (1, {'@': 482}), 23: (1, {'@': 482}), 25: (1, {'@': 482}), 26: (1, {'@': 482}), 63: (1, {'@': 482}), 27: (1, {'@': 482}), 28: (1, {'@': 482}), 29: (1, {'@': 482}), 30: (1, {'@': 482}), 31: (1, {'@': 482}), 33: (1, {'@': 482}), 64: (1, {'@': 482}), 66: (1, {'@': 482}), 67: (1, {'@': 482}), 34: (1, {'@': 482}), 36: (1, {'@': 482}), 37: (1, {'@': 482}), 68: (1, {'@': 482}), 38: (1, {'@': 482}), 69: (1, {'@': 482}), 70: (1, {'@': 482}), 71: (1, {'@': 482}), 40: (1, {'@': 482}), 72: (1, {'@': 482}), 41: (1, {'@': 482}), 73: (1, {'@': 482}), 74: (1, {'@': 482}), 75: (1, {'@': 482})}, 2576: {4: (0, 405), 7: (0, 45), 161: (0, 413), 27: (0, 408), 126: (0, 2228), 215: (0, 1790), 50: (0, 1792), 26: (0, 1797), 180: (0, 1807), 38: (0, 1811), 183: (0, 1813), 167: (0, 1817), 28: (0, 33), 61: (0, 25), 47: (0, 1820), 164: (0, 1824), 37: (0, 1828), 45: (0, 1833), 169: (0, 1836), 163: (0, 1842), 165: (0, 1846), 6: (0, 20), 185: (0, 1849), 168: (0, 1853), 217: (0, 1857), 214: (0, 2235), 57: (1, {'@': 937}), 60: (1, {'@': 937})}, 2577: {43: (1, {'@': 483}), 1: (1, {'@': 483}), 2: (1, {'@': 483}), 44: (1, {'@': 483}), 45: (1, {'@': 483}), 47: (1, {'@': 483}), 48: (1, {'@': 483}), 4: (1, {'@': 483}), 49: (1, {'@': 483}), 50: (1, {'@': 483}), 51: (1, {'@': 483}), 6: (1, {'@': 483}), 52: (1, {'@': 483}), 8: (1, {'@': 483}), 7: (1, {'@': 483}), 9: (1, {'@': 483}), 53: (1, {'@': 483}), 11: (1, {'@': 483}), 54: (1, {'@': 483}), 55: (1, {'@': 483}), 15: (1, {'@': 483}), 17: (1, {'@': 483}), 57: (1, {'@': 483}), 18: (1, {'@': 483}), 58: (1, {'@': 483}), 59: (1, {'@': 483}), 21: (1, {'@': 483}), 22: (1, {'@': 483}), 60: (1, {'@': 483}), 61: (1, {'@': 483}), 126: (1, {'@': 483}), 62: (1, {'@': 483}), 23: (1, {'@': 483}), 25: (1, {'@': 483}), 26: (1, {'@': 483}), 63: (1, {'@': 483}), 27: (1, {'@': 483}), 28: (1, {'@': 483}), 29: (1, {'@': 483}), 30: (1, {'@': 483}), 31: (1, {'@': 483}), 33: (1, {'@': 483}), 64: (1, {'@': 483}), 66: (1, {'@': 483}), 67: (1, {'@': 483}), 34: (1, {'@': 483}), 36: (1, {'@': 483}), 37: (1, {'@': 483}), 68: (1, {'@': 483}), 38: (1, {'@': 483}), 69: (1, {'@': 483}), 70: (1, {'@': 483}), 71: (1, {'@': 483}), 40: (1, {'@': 483}), 72: (1, {'@': 483}), 41: (1, {'@': 483}), 73: (1, {'@': 483}), 74: (1, {'@': 483}), 75: (1, {'@': 483})}, 2578: {126: (1, {'@': 1225}), 146: (1, {'@': 1225})}, 2579: {57: (1, {'@': 741}), 60: (1, {'@': 741})}, 2580: {288: (0, 1534), 290: (0, 1521), 8: (0, 1510), 52: (0, 1498), 292: (0, 1531), 293: (0, 1500), 289: (0, 2079)}, 2581: {112: (0, 241)}, 2582: {230: (1, {'@': 717}), 60: (1, {'@': 717}), 235: (1, {'@': 717}), 240: (1, {'@': 717}), 126: (1, {'@': 717}), 231: (1, {'@': 717}), 234: (1, {'@': 717}), 57: (1, {'@': 717}), 241: (1, {'@': 717}), 243: (1, {'@': 717})}, 2583: {6: (1, {'@': 1672}), 60: (1, {'@': 1672}), 7: (1, {'@': 1672}), 126: (1, {'@': 1672}), 61: (1, {'@': 1672}), 45: (1, {'@': 1672}), 37: (1, {'@': 1672}), 38: (1, {'@': 1672}), 47: (1, {'@': 1672}), 26: (1, {'@': 1672}), 27: (1, {'@': 1672}), 4: (1, {'@': 1672}), 28: (1, {'@': 1672}), 50: (1, {'@': 1672}), 57: (1, {'@': 1672})}, 2584: {126: (1, {'@': 1226}), 146: (1, {'@': 1226})}, 2585: {4: (0, 405), 7: (0, 45), 161: (0, 413), 27: (0, 408), 215: (0, 1790), 50: (0, 1792), 26: (0, 1797), 214: (0, 2213), 180: (0, 1807), 38: (0, 1811), 183: (0, 1813), 167: (0, 1817), 28: (0, 33), 61: (0, 25), 47: (0, 1820), 164: (0, 1824), 37: (0, 1828), 45: (0, 1833), 169: (0, 1836), 163: (0, 1842), 165: (0, 1846), 6: (0, 20), 185: (0, 1849), 168: (0, 1853), 217: (0, 1857)}, 2586: {112: (0, 237)}, 2587: {77: (0, 17), 78: (0, 1960), 79: (0, 1973), 86: (0, 2110), 12: (0, 396), 81: (0, 2295), 82: (0, 791), 83: (0, 809), 84: (0, 811), 85: (0, 816), 10: (0, 826), 87: (0, 842), 35: (0, 844), 88: (0, 848), 89: (0, 2384), 90: (0, 853), 91: (0, 863), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 56: (0, 783), 95: (0, 786), 96: (0, 789), 97: (0, 2370), 98: (0, 793), 19: (0, 800), 711: (0, 2117), 13: (0, 802), 32: (0, 807), 99: (0, 812), 100: (0, 817), 20: (0, 822), 102: (0, 823), 103: (0, 825), 105: (0, 830), 65: (0, 834), 106: (0, 838), 107: (0, 2409), 486: (0, 2118), 108: (0, 400), 109: (0, 390), 46: (0, 781), 80: (0, 2414), 194: (0, 2120), 110: (0, 799), 111: (0, 821), 14: (0, 399), 112: (0, 2376), 113: (0, 828), 114: (0, 832), 0: (0, 846), 42: (0, 858), 39: (0, 860), 115: (0, 44), 116: (0, 780), 5: (0, 787), 117: (0, 804), 24: (0, 814), 118: (0, 819), 119: (0, 836), 120: (0, 840), 122: (0, 850), 3: (0, 855), 123: (0, 856), 124: (0, 864)}, 2588: {126: (1, {'@': 1224}), 146: (1, {'@': 1224})}, 2589: {443: (0, 325)}, 2590: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 194: (0, 2391), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 86: (0, 2387), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2591: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 611: (0, 316), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 86: (0, 2020), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2592: {126: (0, 254), 412: (0, 256), 150: (0, 1554), 60: (1, {'@': 1233}), 57: (1, {'@': 1233})}, 2593: {146: (0, 287)}, 2594: {53: (0, 387), 172: (0, 1454)}, 2595: {57: (1, {'@': 800}), 60: (1, {'@': 800})}, 2596: {57: (1, {'@': 767}), 60: (1, {'@': 767})}, 2597: {60: (0, 253)}, 2598: {219: (0, 2385), 12: (0, 2406), 16: (0, 2407), 109: (0, 2410), 14: (0, 2413)}, 2599: {144: (0, 2316), 115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 145: (0, 1226), 92: (0, 1944), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 86: (0, 2389), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}, 2600: {115: (0, 44), 77: (0, 17), 108: (0, 400), 109: (0, 390), 92: (0, 1944), 107: (0, 2409), 112: (0, 2376), 93: (0, 1949), 94: (0, 1954), 16: (0, 391), 78: (0, 1960), 81: (0, 2295), 79: (0, 1973), 116: (0, 780), 46: (0, 781), 80: (0, 2414), 56: (0, 783), 95: (0, 786), 12: (0, 396), 5: (0, 787), 96: (0, 789), 86: (0, 2593), 97: (0, 2370), 82: (0, 791), 98: (0, 793), 110: (0, 799), 19: (0, 800), 13: (0, 802), 117: (0, 804), 32: (0, 807), 83: (0, 809), 84: (0, 811), 194: (0, 2597), 99: (0, 812), 24: (0, 814), 85: (0, 816), 100: (0, 817), 118: (0, 819), 111: (0, 821), 20: (0, 822), 102: (0, 823), 103: (0, 825), 14: (0, 399), 89: (0, 2384), 10: (0, 826), 113: (0, 828), 105: (0, 830), 114: (0, 832), 65: (0, 834), 119: (0, 836), 106: (0, 838), 120: (0, 840), 87: (0, 842), 35: (0, 844), 0: (0, 846), 88: (0, 848), 122: (0, 850), 90: (0, 853), 3: (0, 855), 123: (0, 856), 42: (0, 858), 39: (0, 860), 91: (0, 863), 124: (0, 864)}}, 'start_states': {'start': 297}, 'end_states': {'start': 1633}}, '__type__': 'ParsingFrontend'}, 'rules': [{'@': 303}, {'@': 304}, {'@': 305}, {'@': 306}, {'@': 307}, {'@': 308}, {'@': 309}, {'@': 310}, {'@': 311}, {'@': 312}, {'@': 313}, {'@': 314}, {'@': 315}, {'@': 316}, {'@': 317}, {'@': 318}, {'@': 319}, {'@': 320}, {'@': 321}, {'@': 322}, {'@': 323}, {'@': 324}, {'@': 325}, {'@': 326}, {'@': 327}, {'@': 328}, {'@': 329}, {'@': 330}, {'@': 331}, {'@': 332}, {'@': 333}, {'@': 334}, {'@': 335}, {'@': 336}, {'@': 337}, {'@': 338}, {'@': 339}, {'@': 340}, {'@': 341}, {'@': 342}, {'@': 343}, {'@': 344}, {'@': 345}, {'@': 346}, {'@': 347}, {'@': 348}, {'@': 349}, {'@': 350}, {'@': 351}, {'@': 352}, {'@': 353}, {'@': 354}, {'@': 355}, {'@': 356}, {'@': 357}, {'@': 358}, {'@': 359}, {'@': 360}, {'@': 361}, {'@': 362}, {'@': 363}, {'@': 364}, {'@': 365}, {'@': 366}, {'@': 367}, {'@': 368}, {'@': 369}, {'@': 370}, {'@': 371}, {'@': 372}, {'@': 373}, {'@': 374}, {'@': 375}, {'@': 376}, {'@': 377}, {'@': 378}, {'@': 379}, {'@': 380}, {'@': 381}, {'@': 382}, {'@': 383}, {'@': 384}, {'@': 385}, {'@': 386}, {'@': 387}, {'@': 388}, {'@': 389}, {'@': 390}, {'@': 391}, {'@': 392}, {'@': 393}, {'@': 394}, {'@': 395}, {'@': 396}, {'@': 397}, {'@': 398}, {'@': 399}, {'@': 400}, {'@': 401}, {'@': 402}, {'@': 403}, {'@': 404}, {'@': 405}, {'@': 406}, {'@': 407}, {'@': 408}, {'@': 409}, {'@': 410}, {'@': 411}, {'@': 412}, {'@': 413}, {'@': 414}, {'@': 415}, {'@': 416}, {'@': 417}, {'@': 418}, {'@': 419}, {'@': 420}, {'@': 421}, {'@': 422}, {'@': 423}, {'@': 424}, {'@': 425}, {'@': 426}, {'@': 427}, {'@': 428}, {'@': 429}, {'@': 430}, {'@': 431}, {'@': 432}, {'@': 433}, {'@': 434}, {'@': 435}, {'@': 436}, {'@': 437}, {'@': 438}, {'@': 439}, {'@': 440}, {'@': 441}, {'@': 442}, {'@': 443}, {'@': 444}, {'@': 445}, {'@': 446}, {'@': 447}, {'@': 448}, {'@': 449}, {'@': 450}, {'@': 451}, {'@': 452}, {'@': 453}, {'@': 454}, {'@': 455}, {'@': 456}, {'@': 457}, {'@': 458}, {'@': 459}, {'@': 460}, {'@': 461}, {'@': 462}, {'@': 463}, {'@': 464}, {'@': 465}, {'@': 466}, {'@': 467}, {'@': 468}, {'@': 469}, {'@': 470}, {'@': 471}, {'@': 472}, {'@': 473}, {'@': 474}, {'@': 475}, {'@': 476}, {'@': 477}, {'@': 478}, {'@': 479}, {'@': 480}, {'@': 481}, {'@': 482}, {'@': 483}, {'@': 484}, {'@': 485}, {'@': 486}, {'@': 487}, {'@': 488}, {'@': 489}, {'@': 490}, {'@': 491}, {'@': 492}, {'@': 493}, {'@': 494}, {'@': 495}, {'@': 496}, {'@': 497}, {'@': 498}, {'@': 499}, {'@': 500}, {'@': 501}, {'@': 502}, {'@': 503}, {'@': 504}, {'@': 505}, {'@': 506}, {'@': 507}, {'@': 508}, {'@': 509}, {'@': 510}, {'@': 511}, {'@': 512}, {'@': 513}, {'@': 514}, {'@': 515}, {'@': 516}, {'@': 517}, {'@': 518}, {'@': 519}, {'@': 520}, {'@': 521}, {'@': 522}, {'@': 523}, {'@': 524}, {'@': 525}, {'@': 526}, {'@': 527}, {'@': 528}, {'@': 529}, {'@': 530}, {'@': 531}, {'@': 532}, {'@': 533}, {'@': 534}, {'@': 535}, {'@': 536}, {'@': 537}, {'@': 538}, {'@': 539}, {'@': 540}, {'@': 541}, {'@': 542}, {'@': 543}, {'@': 544}, {'@': 545}, {'@': 546}, {'@': 547}, {'@': 548}, {'@': 549}, {'@': 550}, {'@': 551}, {'@': 552}, {'@': 553}, {'@': 554}, {'@': 555}, {'@': 556}, {'@': 557}, {'@': 558}, {'@': 559}, {'@': 560}, {'@': 561}, {'@': 562}, {'@': 563}, {'@': 564}, {'@': 565}, {'@': 566}, {'@': 567}, {'@': 568}, {'@': 569}, {'@': 570}, {'@': 571}, {'@': 572}, {'@': 573}, {'@': 574}, {'@': 575}, {'@': 576}, {'@': 577}, {'@': 578}, {'@': 579}, {'@': 580}, {'@': 581}, {'@': 582}, {'@': 583}, {'@': 584}, {'@': 585}, {'@': 586}, {'@': 587}, {'@': 588}, {'@': 589}, {'@': 590}, {'@': 591}, {'@': 592}, {'@': 593}, {'@': 594}, {'@': 595}, {'@': 596}, {'@': 597}, {'@': 598}, {'@': 599}, {'@': 600}, {'@': 601}, {'@': 602}, {'@': 603}, {'@': 604}, {'@': 605}, {'@': 606}, {'@': 607}, {'@': 608}, {'@': 609}, {'@': 610}, {'@': 611}, {'@': 612}, {'@': 613}, {'@': 614}, {'@': 615}, {'@': 616}, {'@': 617}, {'@': 618}, {'@': 619}, {'@': 620}, {'@': 621}, {'@': 622}, {'@': 623}, {'@': 624}, {'@': 625}, {'@': 626}, {'@': 627}, {'@': 628}, {'@': 629}, {'@': 630}, {'@': 631}, {'@': 632}, {'@': 633}, {'@': 634}, {'@': 635}, {'@': 636}, {'@': 637}, {'@': 638}, {'@': 639}, {'@': 640}, {'@': 641}, {'@': 642}, {'@': 643}, {'@': 644}, {'@': 645}, {'@': 646}, {'@': 647}, {'@': 648}, {'@': 649}, {'@': 650}, {'@': 651}, {'@': 652}, {'@': 653}, {'@': 654}, {'@': 655}, {'@': 656}, {'@': 657}, {'@': 658}, {'@': 659}, {'@': 660}, {'@': 661}, {'@': 662}, {'@': 663}, {'@': 664}, {'@': 665}, {'@': 666}, {'@': 667}, {'@': 668}, {'@': 669}, {'@': 670}, {'@': 671}, {'@': 672}, {'@': 673}, {'@': 674}, {'@': 675}, {'@': 676}, {'@': 677}, {'@': 678}, {'@': 679}, {'@': 680}, {'@': 681}, {'@': 682}, {'@': 683}, {'@': 684}, {'@': 685}, {'@': 686}, {'@': 687}, {'@': 688}, {'@': 689}, {'@': 690}, {'@': 691}, {'@': 692}, {'@': 693}, {'@': 694}, {'@': 695}, {'@': 696}, {'@': 697}, {'@': 698}, {'@': 699}, {'@': 700}, {'@': 701}, {'@': 702}, {'@': 703}, {'@': 704}, {'@': 705}, {'@': 706}, {'@': 707}, {'@': 708}, {'@': 709}, {'@': 710}, {'@': 711}, {'@': 712}, {'@': 713}, {'@': 714}, {'@': 715}, {'@': 716}, {'@': 717}, {'@': 718}, {'@': 719}, {'@': 720}, {'@': 721}, {'@': 722}, {'@': 723}, {'@': 724}, {'@': 725}, {'@': 726}, {'@': 727}, {'@': 728}, {'@': 729}, {'@': 730}, {'@': 731}, {'@': 732}, {'@': 733}, {'@': 734}, {'@': 735}, {'@': 736}, {'@': 737}, {'@': 738}, {'@': 739}, {'@': 740}, {'@': 741}, {'@': 742}, {'@': 743}, {'@': 744}, {'@': 745}, {'@': 746}, {'@': 747}, {'@': 748}, {'@': 749}, {'@': 750}, {'@': 751}, {'@': 752}, {'@': 753}, {'@': 754}, {'@': 755}, {'@': 756}, {'@': 757}, {'@': 758}, {'@': 759}, {'@': 760}, {'@': 761}, {'@': 762}, {'@': 763}, {'@': 764}, {'@': 765}, {'@': 766}, {'@': 767}, {'@': 768}, {'@': 769}, {'@': 770}, {'@': 771}, {'@': 772}, {'@': 773}, {'@': 774}, {'@': 775}, {'@': 776}, {'@': 777}, {'@': 778}, {'@': 779}, {'@': 780}, {'@': 781}, {'@': 782}, {'@': 783}, {'@': 784}, {'@': 785}, {'@': 786}, {'@': 787}, {'@': 788}, {'@': 789}, {'@': 790}, {'@': 791}, {'@': 792}, {'@': 793}, {'@': 794}, {'@': 795}, {'@': 796}, {'@': 797}, {'@': 798}, {'@': 799}, {'@': 800}, {'@': 801}, {'@': 802}, {'@': 803}, {'@': 804}, {'@': 805}, {'@': 806}, {'@': 807}, {'@': 808}, {'@': 809}, {'@': 810}, {'@': 811}, {'@': 812}, {'@': 813}, {'@': 814}, {'@': 815}, {'@': 816}, {'@': 817}, {'@': 818}, {'@': 819}, {'@': 820}, {'@': 821}, {'@': 822}, {'@': 823}, {'@': 824}, {'@': 825}, {'@': 826}, {'@': 827}, {'@': 828}, {'@': 829}, {'@': 830}, {'@': 831}, {'@': 832}, {'@': 833}, {'@': 834}, {'@': 835}, {'@': 836}, {'@': 837}, {'@': 838}, {'@': 839}, {'@': 840}, {'@': 841}, {'@': 842}, {'@': 843}, {'@': 844}, {'@': 845}, {'@': 846}, {'@': 847}, {'@': 848}, {'@': 849}, {'@': 850}, {'@': 851}, {'@': 852}, {'@': 853}, {'@': 854}, {'@': 855}, {'@': 856}, {'@': 857}, {'@': 858}, {'@': 859}, {'@': 860}, {'@': 861}, {'@': 862}, {'@': 863}, {'@': 864}, {'@': 865}, {'@': 866}, {'@': 867}, {'@': 868}, {'@': 869}, {'@': 870}, {'@': 871}, {'@': 872}, {'@': 873}, {'@': 874}, {'@': 875}, {'@': 876}, {'@': 877}, {'@': 878}, {'@': 879}, {'@': 880}, {'@': 881}, {'@': 882}, {'@': 883}, {'@': 884}, {'@': 885}, {'@': 886}, {'@': 887}, {'@': 888}, {'@': 889}, {'@': 890}, {'@': 891}, {'@': 892}, {'@': 893}, {'@': 894}, {'@': 895}, {'@': 896}, {'@': 897}, {'@': 898}, {'@': 899}, {'@': 900}, {'@': 901}, {'@': 902}, {'@': 903}, {'@': 904}, {'@': 905}, {'@': 906}, {'@': 907}, {'@': 908}, {'@': 909}, {'@': 910}, {'@': 911}, {'@': 912}, {'@': 913}, {'@': 914}, {'@': 915}, {'@': 916}, {'@': 917}, {'@': 918}, {'@': 919}, {'@': 920}, {'@': 921}, {'@': 922}, {'@': 923}, {'@': 924}, {'@': 925}, {'@': 926}, {'@': 927}, {'@': 928}, {'@': 929}, {'@': 930}, {'@': 931}, {'@': 932}, {'@': 933}, {'@': 934}, {'@': 935}, {'@': 936}, {'@': 937}, {'@': 938}, {'@': 939}, {'@': 940}, {'@': 941}, {'@': 942}, {'@': 943}, {'@': 944}, {'@': 945}, {'@': 946}, {'@': 947}, {'@': 948}, {'@': 949}, {'@': 950}, {'@': 951}, {'@': 952}, {'@': 953}, {'@': 954}, {'@': 955}, {'@': 956}, {'@': 957}, {'@': 958}, {'@': 959}, {'@': 960}, {'@': 961}, {'@': 962}, {'@': 963}, {'@': 964}, {'@': 965}, {'@': 966}, {'@': 967}, {'@': 968}, {'@': 969}, {'@': 970}, {'@': 971}, {'@': 972}, {'@': 973}, {'@': 974}, {'@': 975}, {'@': 976}, {'@': 977}, {'@': 978}, {'@': 979}, {'@': 980}, {'@': 981}, {'@': 982}, {'@': 983}, {'@': 984}, {'@': 985}, {'@': 986}, {'@': 987}, {'@': 988}, {'@': 989}, {'@': 990}, {'@': 991}, {'@': 992}, {'@': 993}, {'@': 994}, {'@': 995}, {'@': 996}, {'@': 997}, {'@': 998}, {'@': 999}, {'@': 1000}, {'@': 1001}, {'@': 1002}, {'@': 1003}, {'@': 1004}, {'@': 1005}, {'@': 1006}, {'@': 1007}, {'@': 1008}, {'@': 1009}, {'@': 1010}, {'@': 1011}, {'@': 1012}, {'@': 1013}, {'@': 1014}, {'@': 1015}, {'@': 1016}, {'@': 1017}, {'@': 1018}, {'@': 1019}, {'@': 1020}, {'@': 1021}, {'@': 1022}, {'@': 1023}, {'@': 1024}, {'@': 1025}, {'@': 1026}, {'@': 1027}, {'@': 1028}, {'@': 1029}, {'@': 1030}, {'@': 1031}, {'@': 1032}, {'@': 1033}, {'@': 1034}, {'@': 1035}, {'@': 1036}, {'@': 1037}, {'@': 1038}, {'@': 1039}, {'@': 1040}, {'@': 1041}, {'@': 1042}, {'@': 1043}, {'@': 1044}, {'@': 1045}, {'@': 1046}, {'@': 1047}, {'@': 1048}, {'@': 1049}, {'@': 1050}, {'@': 1051}, {'@': 1052}, {'@': 1053}, {'@': 1054}, {'@': 1055}, {'@': 1056}, {'@': 1057}, {'@': 1058}, {'@': 1059}, {'@': 1060}, {'@': 1061}, {'@': 1062}, {'@': 1063}, {'@': 1064}, {'@': 1065}, {'@': 1066}, {'@': 1067}, {'@': 1068}, {'@': 1069}, {'@': 1070}, {'@': 1071}, {'@': 1072}, {'@': 1073}, {'@': 1074}, {'@': 1075}, {'@': 1076}, {'@': 1077}, {'@': 1078}, {'@': 1079}, {'@': 1080}, {'@': 1081}, {'@': 1082}, {'@': 1083}, {'@': 1084}, {'@': 1085}, {'@': 1086}, {'@': 1087}, {'@': 1088}, {'@': 1089}, {'@': 1090}, {'@': 1091}, {'@': 1092}, {'@': 1093}, {'@': 1094}, {'@': 1095}, {'@': 1096}, {'@': 1097}, {'@': 1098}, {'@': 1099}, {'@': 1100}, {'@': 1101}, {'@': 1102}, {'@': 1103}, {'@': 1104}, {'@': 1105}, {'@': 1106}, {'@': 1107}, {'@': 1108}, {'@': 1109}, {'@': 1110}, {'@': 1111}, {'@': 1112}, {'@': 1113}, {'@': 1114}, {'@': 1115}, {'@': 1116}, {'@': 1117}, {'@': 1118}, {'@': 1119}, {'@': 1120}, {'@': 1121}, {'@': 1122}, {'@': 1123}, {'@': 1124}, {'@': 1125}, {'@': 1126}, {'@': 1127}, {'@': 1128}, {'@': 1129}, {'@': 1130}, {'@': 1131}, {'@': 1132}, {'@': 1133}, {'@': 1134}, {'@': 1135}, {'@': 1136}, {'@': 1137}, {'@': 1138}, {'@': 1139}, {'@': 1140}, {'@': 1141}, {'@': 1142}, {'@': 1143}, {'@': 1144}, {'@': 1145}, {'@': 1146}, {'@': 1147}, {'@': 1148}, {'@': 1149}, {'@': 1150}, {'@': 1151}, {'@': 1152}, {'@': 1153}, {'@': 1154}, {'@': 1155}, {'@': 1156}, {'@': 1157}, {'@': 1158}, {'@': 1159}, {'@': 1160}, {'@': 1161}, {'@': 1162}, {'@': 1163}, {'@': 1164}, {'@': 1165}, {'@': 1166}, {'@': 1167}, {'@': 1168}, {'@': 1169}, {'@': 1170}, {'@': 1171}, {'@': 1172}, {'@': 1173}, {'@': 1174}, {'@': 1175}, {'@': 1176}, {'@': 1177}, {'@': 1178}, {'@': 1179}, {'@': 1180}, {'@': 1181}, {'@': 1182}, {'@': 1183}, {'@': 1184}, {'@': 1185}, {'@': 1186}, {'@': 1187}, {'@': 1188}, {'@': 1189}, {'@': 1190}, {'@': 1191}, {'@': 1192}, {'@': 1193}, {'@': 1194}, {'@': 1195}, {'@': 1196}, {'@': 1197}, {'@': 1198}, {'@': 1199}, {'@': 1200}, {'@': 1201}, {'@': 1202}, {'@': 1203}, {'@': 1204}, {'@': 1205}, {'@': 1206}, {'@': 1207}, {'@': 1208}, {'@': 1209}, {'@': 1210}, {'@': 1211}, {'@': 1212}, {'@': 1213}, {'@': 1214}, {'@': 1215}, {'@': 1216}, {'@': 1217}, {'@': 1218}, {'@': 1219}, {'@': 1220}, {'@': 1221}, {'@': 1222}, {'@': 1223}, {'@': 1224}, {'@': 1225}, {'@': 1226}, {'@': 1227}, {'@': 1228}, {'@': 1229}, {'@': 1230}, {'@': 1231}, {'@': 1232}, {'@': 1233}, {'@': 1234}, {'@': 1235}, {'@': 1236}, {'@': 1237}, {'@': 1238}, {'@': 1239}, {'@': 1240}, {'@': 1241}, {'@': 1242}, {'@': 1243}, {'@': 1244}, {'@': 1245}, {'@': 1246}, {'@': 1247}, {'@': 1248}, {'@': 1249}, {'@': 1250}, {'@': 1251}, {'@': 1252}, {'@': 1253}, {'@': 1254}, {'@': 1255}, {'@': 1256}, {'@': 1257}, {'@': 1258}, {'@': 1259}, {'@': 1260}, {'@': 1261}, {'@': 1262}, {'@': 1263}, {'@': 1264}, {'@': 1265}, {'@': 1266}, {'@': 1267}, {'@': 1268}, {'@': 1269}, {'@': 1270}, {'@': 1271}, {'@': 1272}, {'@': 1273}, {'@': 1274}, {'@': 1275}, {'@': 1276}, {'@': 1277}, {'@': 1278}, {'@': 1279}, {'@': 1280}, {'@': 1281}, {'@': 1282}, {'@': 1283}, {'@': 1284}, {'@': 1285}, {'@': 1286}, {'@': 1287}, {'@': 1288}, {'@': 1289}, {'@': 1290}, {'@': 1291}, {'@': 1292}, {'@': 1293}, {'@': 1294}, {'@': 1295}, {'@': 1296}, {'@': 1297}, {'@': 1298}, {'@': 1299}, {'@': 1300}, {'@': 1301}, {'@': 1302}, {'@': 1303}, {'@': 1304}, {'@': 1305}, {'@': 1306}, {'@': 1307}, {'@': 1308}, {'@': 1309}, {'@': 1310}, {'@': 1311}, {'@': 1312}, {'@': 1313}, {'@': 1314}, {'@': 1315}, {'@': 1316}, {'@': 1317}, {'@': 1318}, {'@': 1319}, {'@': 1320}, {'@': 1321}, {'@': 1322}, {'@': 1323}, {'@': 1324}, {'@': 1325}, {'@': 1326}, {'@': 1327}, {'@': 1328}, {'@': 1329}, {'@': 1330}, {'@': 1331}, {'@': 1332}, {'@': 1333}, {'@': 1334}, {'@': 1335}, {'@': 1336}, {'@': 1337}, {'@': 1338}, {'@': 1339}, {'@': 1340}, {'@': 1341}, {'@': 1342}, {'@': 1343}, {'@': 1344}, {'@': 1345}, {'@': 1346}, {'@': 1347}, {'@': 1348}, {'@': 1349}, {'@': 1350}, {'@': 1351}, {'@': 1352}, {'@': 1353}, {'@': 1354}, {'@': 1355}, {'@': 1356}, {'@': 1357}, {'@': 1358}, {'@': 1359}, {'@': 1360}, {'@': 1361}, {'@': 1362}, {'@': 1363}, {'@': 1364}, {'@': 1365}, {'@': 1366}, {'@': 1367}, {'@': 1368}, {'@': 1369}, {'@': 1370}, {'@': 1371}, {'@': 1372}, {'@': 1373}, {'@': 1374}, {'@': 1375}, {'@': 1376}, {'@': 1377}, {'@': 1378}, {'@': 1379}, {'@': 1380}, {'@': 1381}, {'@': 1382}, {'@': 1383}, {'@': 1384}, {'@': 1385}, {'@': 1386}, {'@': 1387}, {'@': 1388}, {'@': 1389}, {'@': 1390}, {'@': 1391}, {'@': 1392}, {'@': 1393}, {'@': 1394}, {'@': 1395}, {'@': 1396}, {'@': 1397}, {'@': 1398}, {'@': 1399}, {'@': 1400}, {'@': 1401}, {'@': 1402}, {'@': 1403}, {'@': 1404}, {'@': 1405}, {'@': 1406}, {'@': 1407}, {'@': 1408}, {'@': 1409}, {'@': 1410}, {'@': 1411}, {'@': 1412}, {'@': 1413}, {'@': 1414}, {'@': 1415}, {'@': 1416}, {'@': 1417}, {'@': 1418}, {'@': 1419}, {'@': 1420}, {'@': 1421}, {'@': 1422}, {'@': 1423}, {'@': 1424}, {'@': 1425}, {'@': 1426}, {'@': 1427}, {'@': 1428}, {'@': 1429}, {'@': 1430}, {'@': 1431}, {'@': 1432}, {'@': 1433}, {'@': 1434}, {'@': 1435}, {'@': 1436}, {'@': 1437}, {'@': 1438}, {'@': 1439}, {'@': 1440}, {'@': 1441}, {'@': 1442}, {'@': 1443}, {'@': 1444}, {'@': 1445}, {'@': 1446}, {'@': 1447}, {'@': 1448}, {'@': 1449}, {'@': 1450}, {'@': 1451}, {'@': 1452}, {'@': 1453}, {'@': 1454}, {'@': 1455}, {'@': 1456}, {'@': 1457}, {'@': 1458}, {'@': 1459}, {'@': 1460}, {'@': 1461}, {'@': 1462}, {'@': 1463}, {'@': 1464}, {'@': 1465}, {'@': 1466}, {'@': 1467}, {'@': 1468}, {'@': 1469}, {'@': 1470}, {'@': 1471}, {'@': 1472}, {'@': 1473}, {'@': 1474}, {'@': 1475}, {'@': 1476}, {'@': 1477}, {'@': 1478}, {'@': 1479}, {'@': 1480}, {'@': 1481}, {'@': 1482}, {'@': 1483}, {'@': 1484}, {'@': 1485}, {'@': 1486}, {'@': 1487}, {'@': 1488}, {'@': 1489}, {'@': 1490}, {'@': 1491}, {'@': 1492}, {'@': 1493}, {'@': 1494}, {'@': 1495}, {'@': 1496}, {'@': 1497}, {'@': 1498}, {'@': 1499}, {'@': 1500}, {'@': 1501}, {'@': 1502}, {'@': 1503}, {'@': 1504}, {'@': 1505}, {'@': 1506}, {'@': 1507}, {'@': 1508}, {'@': 1509}, {'@': 1510}, {'@': 1511}, {'@': 1512}, {'@': 1513}, {'@': 1514}, {'@': 1515}, {'@': 1516}, {'@': 1517}, {'@': 1518}, {'@': 1519}, {'@': 1520}, {'@': 1521}, {'@': 1522}, {'@': 1523}, {'@': 1524}, {'@': 1525}, {'@': 1526}, {'@': 1527}, {'@': 1528}, {'@': 1529}, {'@': 1530}, {'@': 1531}, {'@': 1532}, {'@': 1533}, {'@': 1534}, {'@': 1535}, {'@': 1536}, {'@': 1537}, {'@': 1538}, {'@': 1539}, {'@': 1540}, {'@': 1541}, {'@': 1542}, {'@': 1543}, {'@': 1544}, {'@': 1545}, {'@': 1546}, {'@': 1547}, {'@': 1548}, {'@': 1549}, {'@': 1550}, {'@': 1551}, {'@': 1552}, {'@': 1553}, {'@': 1554}, {'@': 1555}, {'@': 1556}, {'@': 1557}, {'@': 1558}, {'@': 1559}, {'@': 1560}, {'@': 1561}, {'@': 1562}, {'@': 1563}, {'@': 1564}, {'@': 1565}, {'@': 1566}, {'@': 1567}, {'@': 1568}, {'@': 1569}, {'@': 1570}, {'@': 1571}, {'@': 1572}, {'@': 1573}, {'@': 1574}, {'@': 1575}, {'@': 1576}, {'@': 1577}, {'@': 1578}, {'@': 1579}, {'@': 1580}, {'@': 1581}, {'@': 1582}, {'@': 1583}, {'@': 1584}, {'@': 1585}, {'@': 1586}, {'@': 1587}, {'@': 1588}, {'@': 1589}, {'@': 1590}, {'@': 1591}, {'@': 1592}, {'@': 1593}, {'@': 1594}, {'@': 1595}, {'@': 1596}, {'@': 1597}, {'@': 1598}, {'@': 1599}, {'@': 1600}, {'@': 1601}, {'@': 1602}, {'@': 1603}, {'@': 1604}, {'@': 1605}, {'@': 1606}, {'@': 1607}, {'@': 1608}, {'@': 1609}, {'@': 1610}, {'@': 1611}, {'@': 1612}, {'@': 1613}, {'@': 1614}, {'@': 1615}, {'@': 1616}, {'@': 1617}, {'@': 1618}, {'@': 1619}, {'@': 1620}, {'@': 1621}, {'@': 1622}, {'@': 1623}, {'@': 1624}, {'@': 1625}, {'@': 1626}, {'@': 1627}, {'@': 1628}, {'@': 1629}, {'@': 1630}, {'@': 1631}, {'@': 1632}, {'@': 1633}, {'@': 1634}, {'@': 1635}, {'@': 1636}, {'@': 1637}, {'@': 1638}, {'@': 1639}, {'@': 1640}, {'@': 1641}, {'@': 1642}, {'@': 1643}, {'@': 1644}, {'@': 1645}, {'@': 1646}, {'@': 1647}, {'@': 1648}, {'@': 1649}, {'@': 1650}, {'@': 1651}, {'@': 1652}, {'@': 1653}, {'@': 1654}, {'@': 1655}, {'@': 1656}, {'@': 1657}, {'@': 1658}, {'@': 1659}, {'@': 1660}, {'@': 1661}, {'@': 1662}, {'@': 1663}, {'@': 1664}, {'@': 1665}, {'@': 1666}, {'@': 1667}, {'@': 1668}, {'@': 1669}, {'@': 1670}, {'@': 1671}, {'@': 1672}, {'@': 1673}, {'@': 1674}, {'@': 1675}, {'@': 1676}, {'@': 1677}, {'@': 1678}, {'@': 1679}, {'@': 1680}, {'@': 1681}, {'@': 1682}, {'@': 1683}, {'@': 1684}, {'@': 1685}, {'@': 1686}, {'@': 1687}, {'@': 1688}, {'@': 1689}, {'@': 1690}, {'@': 1691}, {'@': 1692}, {'@': 1693}, {'@': 1694}, {'@': 1695}, {'@': 1696}, {'@': 1697}, {'@': 1698}, {'@': 1699}, {'@': 1700}, {'@': 1701}, {'@': 1702}, {'@': 1703}, {'@': 1704}, {'@': 1705}, {'@': 1706}, {'@': 1707}, {'@': 1708}, {'@': 1709}, {'@': 1710}, {'@': 1711}, {'@': 1712}, {'@': 1713}, {'@': 1714}, {'@': 1715}, {'@': 1716}, {'@': 1717}, {'@': 1718}, {'@': 1719}, {'@': 1720}, {'@': 1721}, {'@': 1722}, {'@': 1723}, {'@': 1724}, {'@': 1725}, {'@': 1726}, {'@': 1727}, {'@': 1728}, {'@': 1729}, {'@': 1730}, {'@': 1731}, {'@': 1732}, {'@': 1733}, {'@': 1734}, {'@': 1735}, {'@': 1736}, {'@': 1737}, {'@': 1738}, {'@': 1739}, {'@': 1740}, {'@': 1741}, {'@': 1742}, {'@': 1743}, {'@': 1744}], 'options': {'debug': False, 'strict': False, 'keep_all_tokens': False, 'tree_class': None, 'cache': False, 'cache_grammar': False, 'postlex': None, 'parser': 'lalr', 'lexer': 'contextual', 'transformer': None, 'start': ['start'], 'priority': 'normal', 'ambiguity': 'auto', 'regex': False, 'propagate_positions': True, 'lexer_callbacks': {}, 'maybe_placeholders': False, 'edit_terminals': None, 'g_regex_flags': 0, 'use_bytes': False, 'ordered_sets': True, 'import_paths': [], 'source_path': None, '_plugins': {}}, '__type__': 'Lark'} +) +MEMO = ( +{0: {'name': 'THREADPRIVATE_DIRECTIVE', 'pattern': {'value': 'threadprivate', 'flags': [], 'raw': '"threadprivate"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 1: {'name': 'DECLARE_REDUCTION_DIRECTIVE', 'pattern': {'value': '(?:declare\\s+reduction|declare_reduction)', 'flags': [], 'raw': None, '_width': [17, 18446744073709551616], '__type__': 'PatternRE'}, 'priority': 0, '__type__': 'TerminalDef'}, 2: {'name': 'COMBINER_CLAUSE', 'pattern': {'value': 'combiner', 'flags': [], 'raw': '"combiner"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 3: {'name': 'INITIALIZER_CLAUSE', 'pattern': {'value': 'initializer', 'flags': [], 'raw': '"initializer"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 4: {'name': 'DECLARE_INDUCTION_DIRECTIVE', 'pattern': {'value': 'declare_induction', 'flags': [], 'raw': '"declare_induction"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 5: {'name': 'INDUCTOR_CLAUSE', 'pattern': {'value': 'inductor', 'flags': [], 'raw': '"inductor"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 6: {'name': 'COLLECTOR_CLAUSE', 'pattern': {'value': 'collector', 'flags': [], 'raw': '"collector"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 7: {'name': 'SCAN_DIRECTIVE', 'pattern': {'value': 'scan', 'flags': [], 'raw': '"scan"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 8: {'name': 'EXCLUSIVE_CLAUSE', 'pattern': {'value': 'exclusive', 'flags': [], 'raw': '"exclusive"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 9: {'name': 'INCLUSIVE_CLAUSE', 'pattern': {'value': 'inclusive', 'flags': [], 'raw': '"inclusive"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 10: {'name': 'INIT_COMPLETE_CLAUSE', 'pattern': {'value': 'init_complete', 'flags': [], 'raw': '"init_complete"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 11: {'name': 'DECLARE_MAPPER_DIRECTIVE', 'pattern': {'value': '(?:declare\\s+mapper|declare_mapper)', 'flags': [], 'raw': None, '_width': [14, 18446744073709551616], '__type__': 'PatternRE'}, 'priority': 0, '__type__': 'TerminalDef'}, 12: {'name': 'GROUPPRIVATE_DIRECTIVE', 'pattern': {'value': 'groupprivate', 'flags': [], 'raw': '"groupprivate"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 13: {'name': 'DEVICE_TYPE_CLAUSE', 'pattern': {'value': 'device_type', 'flags': [], 'raw': '"device_type"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 14: {'name': 'HOST', 'pattern': {'value': 'host', 'flags': [], 'raw': '"host"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 15: {'name': 'NOHOST', 'pattern': {'value': 'nohost', 'flags': [], 'raw': '"nohost"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 16: {'name': 'ANY', 'pattern': {'value': 'any', 'flags': [], 'raw': '"any"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 17: {'name': 'ALLOCATE_DIRECTIVE', 'pattern': {'value': 'allocate', 'flags': [], 'raw': '"allocate"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 18: {'name': 'ALIGN_CLAUSE', 'pattern': {'value': 'align', 'flags': [], 'raw': '"align"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 19: {'name': 'ALLOCATOR_CLAUSE', 'pattern': {'value': 'allocator', 'flags': [], 'raw': '"allocator"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 20: {'name': 'METADIRECTIVE_DIRECTIVE', 'pattern': {'value': 'metadirective', 'flags': [], 'raw': '"metadirective"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 21: {'name': 'WHEN_CLAUSE', 'pattern': {'value': 'when', 'flags': [], 'raw': '"when"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 22: {'name': 'OTHERWISE_CLAUSE', 'pattern': {'value': 'otherwise', 'flags': [], 'raw': '"otherwise"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 23: {'name': 'DECLARE_VARIANT_DIRECTIVE', 'pattern': {'value': '(?:declare\\s+variant|declare_variant)', 'flags': [], 'raw': None, '_width': [15, 18446744073709551616], '__type__': 'PatternRE'}, 'priority': 0, '__type__': 'TerminalDef'}, 24: {'name': 'ADJUST_ARGS_CLAUSE', 'pattern': {'value': 'adjust_args', 'flags': [], 'raw': '"adjust_args"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 25: {'name': 'NEED_DEVICE_ADDR', 'pattern': {'value': 'need_device_addr', 'flags': [], 'raw': '"need_device_addr"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 26: {'name': 'NEED_DEVICE_PTR', 'pattern': {'value': 'need_device_ptr', 'flags': [], 'raw': '"need_device_ptr"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 27: {'name': 'NOTHING', 'pattern': {'value': 'nothing', 'flags': [], 'raw': '"nothing"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 28: {'name': 'APPEND_ARGS_CLAUSE', 'pattern': {'value': 'append_args', 'flags': [], 'raw': '"append_args"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 29: {'name': 'INTEROP', 'pattern': {'value': 'interop', 'flags': [], 'raw': '"interop"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 30: {'name': 'TARGET', 'pattern': {'value': 'target', 'flags': [], 'raw': '"target"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 31: {'name': 'TARGETSYNC', 'pattern': {'value': 'targetsync', 'flags': [], 'raw': '"targetsync"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 32: {'name': 'MATCH_CLAUSE', 'pattern': {'value': 'match', 'flags': [], 'raw': '"match"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 33: {'name': 'DISPATCH_DIRECTIVE', 'pattern': {'value': 'dispatch', 'flags': [], 'raw': '"dispatch"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 34: {'name': 'INTEROP_CLAUSE', 'pattern': {'value': 'interop', 'flags': [], 'raw': '"interop"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 35: {'name': 'IS_DEVICE_PTR_CLAUSE', 'pattern': {'value': 'is_device_ptr', 'flags': [], 'raw': '"is_device_ptr"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 36: {'name': 'HAS_DEVICE_ADDR_CLAUSE', 'pattern': {'value': 'has_device_addr', 'flags': [], 'raw': '"has_device_addr"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 37: {'name': 'NOCONTEXT_CLAUSE', 'pattern': {'value': 'nocontext', 'flags': [], 'raw': '"nocontext"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 38: {'name': 'NOVARIANTS_CLAUSE', 'pattern': {'value': 'novariants', 'flags': [], 'raw': '"novariants"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 39: {'name': 'DECLARE_SIMD_DIRECTIVE', 'pattern': {'value': '(?:declare\\s+simd|declare_simd)', 'flags': [], 'raw': None, '_width': [12, 18446744073709551616], '__type__': 'PatternRE'}, 'priority': 0, '__type__': 'TerminalDef'}, 40: {'name': 'ALIGNED_CLAUSE', 'pattern': {'value': 'aligned', 'flags': [], 'raw': '"aligned"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 41: {'name': 'LINEAR_CLAUSE', 'pattern': {'value': 'linear', 'flags': [], 'raw': '"linear"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 42: {'name': 'REF', 'pattern': {'value': 'ref', 'flags': [], 'raw': '"ref"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 43: {'name': 'UVAL', 'pattern': {'value': 'uval', 'flags': [], 'raw': '"uval"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 44: {'name': 'VAL', 'pattern': {'value': 'val', 'flags': [], 'raw': '"val"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 45: {'name': 'SIMDLEN_CLAUSE', 'pattern': {'value': 'simdlen', 'flags': [], 'raw': '"simdlen"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 46: {'name': 'UNIFORM_CLAUSE', 'pattern': {'value': 'uniform', 'flags': [], 'raw': '"uniform"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 47: {'name': 'INBRANCH', 'pattern': {'value': 'inbranch', 'flags': [], 'raw': '"inbranch"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 48: {'name': 'NOTINBRANCH', 'pattern': {'value': 'notinbranch', 'flags': [], 'raw': '"notinbranch"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 49: {'name': 'DECLARE_TARGET_DIRECTIVE', 'pattern': {'value': '(?:declare\\s+target|declare_target)', 'flags': [], 'raw': None, '_width': [14, 18446744073709551616], '__type__': 'PatternRE'}, 'priority': 0, '__type__': 'TerminalDef'}, 50: {'name': 'ENTER_CLAUSE', 'pattern': {'value': 'enter', 'flags': [], 'raw': '"enter"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 51: {'name': 'AUTOMAP', 'pattern': {'value': 'automap', 'flags': [], 'raw': '"automap"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 52: {'name': 'INDIRECT_CLAUSE', 'pattern': {'value': 'indirect', 'flags': [], 'raw': '"indirect"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 53: {'name': 'LINK_CLAUSE', 'pattern': {'value': 'link', 'flags': [], 'raw': '"link"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 54: {'name': 'LOCAL_CLAUSE', 'pattern': {'value': 'local', 'flags': [], 'raw': '"local"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 55: {'name': 'REQUIRES_DIRECTIVE', 'pattern': {'value': 'requires', 'flags': [], 'raw': '"requires"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 56: {'name': 'ATOMIC_DEFAULT_MEM_ORDER_CLAUSE', 'pattern': {'value': 'atomic_default_mem_order', 'flags': [], 'raw': '"atomic_default_mem_order"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 57: {'name': 'ACQ_REL', 'pattern': {'value': 'acq_rel', 'flags': [], 'raw': '"acq_rel"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 58: {'name': 'ACQUIRE', 'pattern': {'value': 'acquire', 'flags': [], 'raw': '"acquire"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 59: {'name': 'RELAXED', 'pattern': {'value': 'relaxed', 'flags': [], 'raw': '"relaxed"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 60: {'name': 'SEQ_CST', 'pattern': {'value': 'seq_cst', 'flags': [], 'raw': '"seq_cst"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 61: {'name': 'DYNAMIC_ALLOCATORS_CLAUSE', 'pattern': {'value': 'dynamic_allocators', 'flags': [], 'raw': '"dynamic_allocators"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 62: {'name': 'REVERSE_OFFLOAD_CLAUSE', 'pattern': {'value': 'reverse_offload', 'flags': [], 'raw': '"reverse_offload"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 63: {'name': 'UNIFIED_ADDRESS_CLAUSE', 'pattern': {'value': 'unified_address', 'flags': [], 'raw': '"unified_address"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 64: {'name': 'UNIFIED_SHARED_MEMORY_CLAUSE', 'pattern': {'value': 'unified_shared_memory', 'flags': [], 'raw': '"unified_shared_memory"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 65: {'name': 'SELF_MAPS_CLAUSE', 'pattern': {'value': 'self_maps', 'flags': [], 'raw': '"self_maps"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 66: {'name': 'DEVICE_SAFESYNC_CLAUSE', 'pattern': {'value': 'device_safesync', 'flags': [], 'raw': '"device_safesync"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 67: {'name': 'ASSUME_DIRECTIVE', 'pattern': {'value': 'assume', 'flags': [], 'raw': '"assume"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 68: {'name': 'ABSENT_CLAUSE', 'pattern': {'value': 'absent', 'flags': [], 'raw': '"absent"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 69: {'name': 'CONTAINS_CLAUSE', 'pattern': {'value': 'contains', 'flags': [], 'raw': '"contains"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 70: {'name': 'HOLDS_CLAUSE', 'pattern': {'value': 'holds', 'flags': [], 'raw': '"holds"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 71: {'name': 'NO_OPENMP_CLAUSE', 'pattern': {'value': 'no_openmp', 'flags': [], 'raw': '"no_openmp"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 72: {'name': 'NO_OPENMP_CONSTRUCTS_CLAUSE', 'pattern': {'value': 'no_openmp_constructs', 'flags': [], 'raw': '"no_openmp_constructs"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 73: {'name': 'NO_OPENMP_ROUTINES_CLAUSE', 'pattern': {'value': 'no_openmp_routines', 'flags': [], 'raw': '"no_openmp_routines"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 74: {'name': 'NO_PARALLELISM_CLAUSE', 'pattern': {'value': 'no_parallelism', 'flags': [], 'raw': '"no_parallelism"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 75: {'name': 'NOTHING_DIRECTIVE', 'pattern': {'value': 'nothing', 'flags': [], 'raw': '"nothing"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 76: {'name': 'ERROR_DIRECTIVE', 'pattern': {'value': 'error', 'flags': [], 'raw': '"error"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 77: {'name': 'AT_CLAUSE', 'pattern': {'value': 'at', 'flags': [], 'raw': '"at"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 78: {'name': 'COMPILATION', 'pattern': {'value': 'compilation', 'flags': [], 'raw': '"compilation"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 79: {'name': 'EXECUTION', 'pattern': {'value': 'execution', 'flags': [], 'raw': '"execution"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 80: {'name': 'MESSAGE_CLAUSE', 'pattern': {'value': 'message', 'flags': [], 'raw': '"message"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 81: {'name': 'SEVERITY_CLAUSE', 'pattern': {'value': 'severity', 'flags': [], 'raw': '"severity"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 82: {'name': 'FATAL', 'pattern': {'value': 'fatal', 'flags': [], 'raw': '"fatal"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 83: {'name': 'WARNING', 'pattern': {'value': 'warning', 'flags': [], 'raw': '"warning"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 84: {'name': 'FUSE_DIRECTIVE', 'pattern': {'value': 'fuse', 'flags': [], 'raw': '"fuse"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 85: {'name': 'LOOPRANGE_CLAUSE', 'pattern': {'value': 'looprange', 'flags': [], 'raw': '"looprange"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 86: {'name': 'INTERCHANGE_DIRECTIVE', 'pattern': {'value': 'interchange', 'flags': [], 'raw': '"interchange"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 87: {'name': 'PERMUTATION_CLAUSE', 'pattern': {'value': 'permutation', 'flags': [], 'raw': '"permutation"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 88: {'name': 'REVERSE_DIRECTIVE', 'pattern': {'value': 'reverse', 'flags': [], 'raw': '"reverse"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 89: {'name': 'SPLIT_DIRECTIVE', 'pattern': {'value': 'split', 'flags': [], 'raw': '"split"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 90: {'name': 'COUNTS_CLAUSE', 'pattern': {'value': 'counts', 'flags': [], 'raw': '"counts"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 91: {'name': 'STRIPE_DIRECTIVE', 'pattern': {'value': 'stripe', 'flags': [], 'raw': '"stripe"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 92: {'name': 'SIZES_CLAUSE', 'pattern': {'value': 'sizes', 'flags': [], 'raw': '"sizes"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 93: {'name': 'TILE_DIRECTIVE', 'pattern': {'value': 'tile', 'flags': [], 'raw': '"tile"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 94: {'name': 'UNROLL_DIRECTIVE', 'pattern': {'value': 'unroll', 'flags': [], 'raw': '"unroll"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 95: {'name': 'FULL_CLAUSE', 'pattern': {'value': 'full', 'flags': [], 'raw': '"full"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 96: {'name': 'PARTIAL_CLAUSE', 'pattern': {'value': 'partial', 'flags': [], 'raw': '"partial"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 97: {'name': 'PARALLEL_DIRECTIVE', 'pattern': {'value': 'parallel', 'flags': [], 'raw': '"parallel"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 98: {'name': 'COPYIN_CLAUSE', 'pattern': {'value': 'copyin', 'flags': [], 'raw': '"copyin"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 99: {'name': 'NUM_THREADS_CLAUSE', 'pattern': {'value': 'num_threads', 'flags': [], 'raw': '"num_threads"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 100: {'name': 'STRICT', 'pattern': {'value': 'strict', 'flags': [], 'raw': '"strict"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 101: {'name': 'PROC_BIND_CLAUSE', 'pattern': {'value': 'proc_bind', 'flags': [], 'raw': '"proc_bind"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 102: {'name': 'PRIMARY', 'pattern': {'value': 'primary', 'flags': [], 'raw': '"primary"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 103: {'name': 'SPREAD', 'pattern': {'value': 'spread', 'flags': [], 'raw': '"spread"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 104: {'name': 'SAFESYNC_CLAUSE', 'pattern': {'value': 'safesync', 'flags': [], 'raw': '"safesync"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 105: {'name': 'TEAMS_DIRECTIVE', 'pattern': {'value': 'teams', 'flags': [], 'raw': '"teams"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 106: {'name': 'NUM_TEAMS_CLAUSE', 'pattern': {'value': 'num_teams', 'flags': [], 'raw': '"num_teams"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 107: {'name': 'THREAD_LIMIT_CLAUSE', 'pattern': {'value': 'thread_limit', 'flags': [], 'raw': '"thread_limit"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 108: {'name': 'SIMD_DIRECTIVE', 'pattern': {'value': 'simd', 'flags': [], 'raw': '"simd"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 109: {'name': 'NONTEMPORAL_CLAUSE', 'pattern': {'value': 'nontemporal', 'flags': [], 'raw': '"nontemporal"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 110: {'name': 'ORDER_CLAUSE', 'pattern': {'value': 'order', 'flags': [], 'raw': '"order"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 111: {'name': 'CONCURRENT', 'pattern': {'value': 'concurrent', 'flags': [], 'raw': '"concurrent"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 112: {'name': 'REPRODUCIBLE', 'pattern': {'value': 'reproducible', 'flags': [], 'raw': '"reproducible"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 113: {'name': 'UNCONSTRAINED', 'pattern': {'value': 'unconstrained', 'flags': [], 'raw': '"unconstrained"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 114: {'name': 'SAFELEN_CLAUSE', 'pattern': {'value': 'safelen', 'flags': [], 'raw': '"safelen"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 115: {'name': 'MASKED_DIRECTIVE', 'pattern': {'value': 'masked', 'flags': [], 'raw': '"masked"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 116: {'name': 'FILTER_CLAUSE', 'pattern': {'value': 'filter', 'flags': [], 'raw': '"filter"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 117: {'name': 'SINGLE_DIRECTIVE', 'pattern': {'value': 'single', 'flags': [], 'raw': '"single"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 118: {'name': 'COPYPRIVATE_CLAUSE', 'pattern': {'value': 'copyprivate', 'flags': [], 'raw': '"copyprivate"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 119: {'name': 'SCOPE_DIRECTIVE', 'pattern': {'value': 'scope', 'flags': [], 'raw': '"scope"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 120: {'name': 'SECTIONS_DIRECTIVE', 'pattern': {'value': 'sections', 'flags': [], 'raw': '"sections"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 121: {'name': 'SECTION_DIRECTIVE', 'pattern': {'value': 'section', 'flags': [], 'raw': '"section"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 122: {'name': 'WORKSHARE_DIRECTIVE', 'pattern': {'value': 'workshare', 'flags': [], 'raw': '"workshare"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 123: {'name': 'WORKDISTRIBUTE_DIRECTIVE', 'pattern': {'value': 'workdistribute', 'flags': [], 'raw': '"workdistribute"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 124: {'name': 'FOR_DIRECTIVE', 'pattern': {'value': 'for', 'flags': [], 'raw': '"for"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 125: {'name': 'ORDERED_CLAUSE', 'pattern': {'value': 'ordered', 'flags': [], 'raw': '"ordered"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 126: {'name': 'SCHEDULE_CLAUSE', 'pattern': {'value': 'schedule', 'flags': [], 'raw': '"schedule"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 127: {'name': 'STATIC', 'pattern': {'value': 'static', 'flags': [], 'raw': '"static"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 128: {'name': 'DYNAMIC', 'pattern': {'value': 'dynamic', 'flags': [], 'raw': '"dynamic"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 129: {'name': 'GUIDED', 'pattern': {'value': 'guided', 'flags': [], 'raw': '"guided"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 130: {'name': 'AUTO', 'pattern': {'value': 'auto', 'flags': [], 'raw': '"auto"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 131: {'name': 'RUNTIME', 'pattern': {'value': 'runtime', 'flags': [], 'raw': '"runtime"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 132: {'name': 'MONOTONIC', 'pattern': {'value': 'monotonic', 'flags': [], 'raw': '"monotonic"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 133: {'name': 'NONMONOTONIC', 'pattern': {'value': 'nonmonotonic', 'flags': [], 'raw': '"nonmonotonic"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 134: {'name': 'SIMD', 'pattern': {'value': 'simd', 'flags': [], 'raw': '"simd"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 135: {'name': 'DISTRIBUTE_DIRECTIVE', 'pattern': {'value': 'distribute', 'flags': [], 'raw': '"distribute"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 136: {'name': 'DIST_SCHEDULE_CLAUSE', 'pattern': {'value': 'dist_schedule', 'flags': [], 'raw': '"dist_schedule"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 137: {'name': 'LOOP_DIRECTIVE', 'pattern': {'value': 'loop', 'flags': [], 'raw': '"loop"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 138: {'name': 'BIND_CLAUSE', 'pattern': {'value': 'bind', 'flags': [], 'raw': '"bind"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 139: {'name': 'PARALLEL', 'pattern': {'value': 'parallel', 'flags': [], 'raw': '"parallel"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 140: {'name': 'TEAMS', 'pattern': {'value': 'teams', 'flags': [], 'raw': '"teams"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 141: {'name': 'THREAD', 'pattern': {'value': 'thread', 'flags': [], 'raw': '"thread"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 142: {'name': 'TASK_DIRECTIVE', 'pattern': {'value': 'task', 'flags': [], 'raw': '"task"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 143: {'name': 'TASKLOOP_DIRECTIVE', 'pattern': {'value': 'taskloop', 'flags': [], 'raw': '"taskloop"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 144: {'name': 'GRAINSIZE_CLAUSE', 'pattern': {'value': 'grainsize', 'flags': [], 'raw': '"grainsize"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 145: {'name': 'NUM_TASKS_CLAUSE', 'pattern': {'value': 'num_tasks', 'flags': [], 'raw': '"num_tasks"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 146: {'name': 'TASK_ITERATION_DIRECTIVE', 'pattern': {'value': 'task_iteration', 'flags': [], 'raw': '"task_iteration"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 147: {'name': 'TASKYIELD_DIRECTIVE', 'pattern': {'value': 'taskyield', 'flags': [], 'raw': '"taskyield"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 148: {'name': 'TASKGRAPH_DIRECTIVE', 'pattern': {'value': 'taskgraph', 'flags': [], 'raw': '"taskgraph"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 149: {'name': 'GRAPH_ID_CLAUSE', 'pattern': {'value': 'graph_id', 'flags': [], 'raw': '"graph_id"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 150: {'name': 'GRAPH_RESET_CLAUSE', 'pattern': {'value': 'graph_reset', 'flags': [], 'raw': '"graph_reset"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 151: {'name': 'TARGET_DATA_DIRECTIVE', 'pattern': {'value': '(?:target\\s+data|target_data)', 'flags': [], 'raw': None, '_width': [11, 18446744073709551616], '__type__': 'PatternRE'}, 'priority': 0, '__type__': 'TerminalDef'}, 152: {'name': 'USE_DEVICE_PTR_CLAUSE', 'pattern': {'value': 'use_device_ptr', 'flags': [], 'raw': '"use_device_ptr"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 153: {'name': 'USE_DEVICE_ADDR_CLAUSE', 'pattern': {'value': 'use_device_addr', 'flags': [], 'raw': '"use_device_addr"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 154: {'name': 'TARGET_ENTER_DATA_DIRECTIVE', 'pattern': {'value': '(?:target\\s+enter\\s+data|target_enter_data)', 'flags': [], 'raw': None, '_width': [17, 18446744073709551616], '__type__': 'PatternRE'}, 'priority': 0, '__type__': 'TerminalDef'}, 155: {'name': 'TARGET_EXIT_DATA_DIRECTIVE', 'pattern': {'value': '(?:target\\s+exit\\s+data|target_exit_data)', 'flags': [], 'raw': None, '_width': [16, 18446744073709551616], '__type__': 'PatternRE'}, 'priority': 0, '__type__': 'TerminalDef'}, 156: {'name': 'TARGET_DIRECTIVE', 'pattern': {'value': 'target', 'flags': [], 'raw': '"target"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 157: {'name': 'DEFAULTMAP_CLAUSE', 'pattern': {'value': 'defaultmap', 'flags': [], 'raw': '"defaultmap"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 158: {'name': 'USES_ALLOCATORS_CLAUSE', 'pattern': {'value': 'uses_allocators', 'flags': [], 'raw': '"uses_allocators"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 159: {'name': 'TARGET_UPDATE_DIRECTIVE', 'pattern': {'value': '(?:target\\s+update|target_update)', 'flags': [], 'raw': None, '_width': [13, 18446744073709551616], '__type__': 'PatternRE'}, 'priority': 0, '__type__': 'TerminalDef'}, 160: {'name': 'TO_CLAUSE', 'pattern': {'value': 'to', 'flags': [], 'raw': '"to"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 161: {'name': 'FROM_CLAUSE', 'pattern': {'value': 'from', 'flags': [], 'raw': '"from"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 162: {'name': 'INTEROP_DIRECTIVE', 'pattern': {'value': 'interop', 'flags': [], 'raw': '"interop"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 163: {'name': 'DESTROY_CLAUSE', 'pattern': {'value': 'destroy', 'flags': [], 'raw': '"destroy"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 164: {'name': 'INIT_CLAUSE', 'pattern': {'value': 'init', 'flags': [], 'raw': '"init"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 165: {'name': 'USE_CLAUSE', 'pattern': {'value': 'use', 'flags': [], 'raw': '"use"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 166: {'name': 'CRITICAL_DIRECTIVE', 'pattern': {'value': 'critical', 'flags': [], 'raw': '"critical"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 167: {'name': 'HINT_CLAUSE', 'pattern': {'value': 'hint', 'flags': [], 'raw': '"hint"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 168: {'name': 'BARRIER_DIRECTIVE', 'pattern': {'value': 'barrier', 'flags': [], 'raw': '"barrier"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 169: {'name': 'TASKGROUP_DIRECTIVE', 'pattern': {'value': 'taskgroup', 'flags': [], 'raw': '"taskgroup"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 170: {'name': 'TASK_REDUCTION_CLAUSE', 'pattern': {'value': 'task_reduction', 'flags': [], 'raw': '"task_reduction"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 171: {'name': 'TASKWAIT_DIRECTIVE', 'pattern': {'value': 'taskwait', 'flags': [], 'raw': '"taskwait"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 172: {'name': 'ATOMIC_DIRECTIVE', 'pattern': {'value': 'atomic', 'flags': [], 'raw': '"atomic"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 173: {'name': 'MEMSCOPE_CLAUSE', 'pattern': {'value': 'memscope', 'flags': [], 'raw': '"memscope"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 174: {'name': 'CGROUP', 'pattern': {'value': 'cgroup', 'flags': [], 'raw': '"cgroup"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 175: {'name': 'DEVICE', 'pattern': {'value': 'device', 'flags': [], 'raw': '"device"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 176: {'name': 'READ_CLAUSE', 'pattern': {'value': 'read', 'flags': [], 'raw': '"read"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 177: {'name': 'WRITE_CLAUSE', 'pattern': {'value': 'write', 'flags': [], 'raw': '"write"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 178: {'name': 'CAPTURE_CLAUSE', 'pattern': {'value': 'capture', 'flags': [], 'raw': '"capture"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 179: {'name': 'COMPARE_CLAUSE', 'pattern': {'value': 'compare', 'flags': [], 'raw': '"compare"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 180: {'name': 'FAIL_CLAUSE', 'pattern': {'value': 'fail', 'flags': [], 'raw': '"fail"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 181: {'name': 'WEAK_CLAUSE', 'pattern': {'value': 'weak', 'flags': [], 'raw': '"weak"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 182: {'name': 'ACQ_REL_CLAUSE', 'pattern': {'value': 'acq_rel', 'flags': [], 'raw': '"acq_rel"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 183: {'name': 'ACQUIRE_CLAUSE', 'pattern': {'value': 'acquire', 'flags': [], 'raw': '"acquire"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 184: {'name': 'RELAXED_CLAUSE', 'pattern': {'value': 'relaxed', 'flags': [], 'raw': '"relaxed"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 185: {'name': 'RELEASE_CLAUSE', 'pattern': {'value': 'release', 'flags': [], 'raw': '"release"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 186: {'name': 'SEQ_CST_CLAUSE', 'pattern': {'value': 'seq_cst', 'flags': [], 'raw': '"seq_cst"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 187: {'name': 'FLUSH_DIRECTIVE', 'pattern': {'value': 'flush', 'flags': [], 'raw': '"flush"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 188: {'name': 'DEPOBJ_DIRECTIVE', 'pattern': {'value': 'depobj', 'flags': [], 'raw': '"depobj"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 189: {'name': 'UPDATE_CLAUSE', 'pattern': {'value': 'update', 'flags': [], 'raw': '"update"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 190: {'name': 'ORDERED_DIRECTIVE', 'pattern': {'value': 'ordered', 'flags': [], 'raw': '"ordered"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 191: {'name': 'DOACROSS_CLAUSE', 'pattern': {'value': 'doacross', 'flags': [], 'raw': '"doacross"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 192: {'name': 'SINK', 'pattern': {'value': 'sink', 'flags': [], 'raw': '"sink"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 193: {'name': 'SOURCE', 'pattern': {'value': 'source', 'flags': [], 'raw': '"source"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 194: {'name': 'THREADS_CLAUSE', 'pattern': {'value': 'threads', 'flags': [], 'raw': '"threads"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 195: {'name': 'SIMD_CLAUSE', 'pattern': {'value': 'simd', 'flags': [], 'raw': '"simd"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 196: {'name': 'CANCEL_DIRECTIVE', 'pattern': {'value': 'cancel', 'flags': [], 'raw': '"cancel"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 197: {'name': 'CANCELLATION_POINT_DIRECTIVE', 'pattern': {'value': '(?:cancellation\\s+point|cancellation_point)', 'flags': [], 'raw': None, '_width': [18, 18446744073709551616], '__type__': 'PatternRE'}, 'priority': 0, '__type__': 'TerminalDef'}, 198: {'name': 'APPLY_CLAUSE', 'pattern': {'value': 'apply', 'flags': [], 'raw': '"apply"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 199: {'name': 'DEPEND_CLAUSE', 'pattern': {'value': 'depend', 'flags': [], 'raw': '"depend"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 200: {'name': 'DEPOBJ', 'pattern': {'value': 'depobj', 'flags': [], 'raw': '"depobj"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 201: {'name': 'IN', 'pattern': {'value': 'in', 'flags': [], 'raw': '"in"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 202: {'name': 'INOUT', 'pattern': {'value': 'inout', 'flags': [], 'raw': '"inout"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 203: {'name': 'INOUTSET', 'pattern': {'value': 'inoutset', 'flags': [], 'raw': '"inoutset"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 204: {'name': 'MUTEXINOUTSET', 'pattern': {'value': 'mutexinoutset', 'flags': [], 'raw': '"mutexinoutset"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 205: {'name': 'OUT', 'pattern': {'value': 'out', 'flags': [], 'raw': '"out"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 206: {'name': 'DEVICE_CLAUSE', 'pattern': {'value': 'device', 'flags': [], 'raw': '"device"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 207: {'name': 'ANCESTOR', 'pattern': {'value': 'ancestor', 'flags': [], 'raw': '"ancestor"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 208: {'name': 'DEVICE_NUM', 'pattern': {'value': 'device_num', 'flags': [], 'raw': '"device_num"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 209: {'name': 'DEFAULT_CLAUSE', 'pattern': {'value': 'default', 'flags': [], 'raw': '"default"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 210: {'name': 'NONE', 'pattern': {'value': 'none', 'flags': [], 'raw': '"none"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 211: {'name': 'SHARED', 'pattern': {'value': 'shared', 'flags': [], 'raw': '"shared"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 212: {'name': 'FIRSTPRIVATE', 'pattern': {'value': 'firstprivate', 'flags': [], 'raw': '"firstprivate"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 213: {'name': 'PRIVATE', 'pattern': {'value': 'private', 'flags': [], 'raw': '"private"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 214: {'name': 'AGGREGATE', 'pattern': {'value': 'aggregate', 'flags': [], 'raw': '"aggregate"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 215: {'name': 'ALL', 'pattern': {'value': 'all', 'flags': [], 'raw': '"all"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 216: {'name': 'ALLOCATABLE', 'pattern': {'value': 'allocatable', 'flags': [], 'raw': '"allocatable"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 217: {'name': 'POINTER', 'pattern': {'value': 'pointer', 'flags': [], 'raw': '"pointer"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 218: {'name': 'SCALAR', 'pattern': {'value': 'scalar', 'flags': [], 'raw': '"scalar"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 219: {'name': 'PRIVATE_CLAUSE', 'pattern': {'value': 'private', 'flags': [], 'raw': '"private"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 220: {'name': 'IF_CLAUSE', 'pattern': {'value': 'if', 'flags': [], 'raw': '"if"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 221: {'name': 'FIRSTPRIVATE_CLAUSE', 'pattern': {'value': 'firstprivate', 'flags': [], 'raw': '"firstprivate"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 222: {'name': 'SAVED', 'pattern': {'value': 'saved', 'flags': [], 'raw': '"saved"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 223: {'name': 'REDUCTION_CLAUSE', 'pattern': {'value': 'reduction', 'flags': [], 'raw': '"reduction"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 224: {'name': 'DEFAULT', 'pattern': {'value': 'default', 'flags': [], 'raw': '"default"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 225: {'name': 'INSCAN', 'pattern': {'value': 'inscan', 'flags': [], 'raw': '"inscan"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 226: {'name': 'TASK', 'pattern': {'value': 'task', 'flags': [], 'raw': '"task"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 227: {'name': 'INDUCTION_CLAUSE', 'pattern': {'value': 'induction', 'flags': [], 'raw': '"induction"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 228: {'name': 'SHARED_CLAUSE', 'pattern': {'value': 'shared', 'flags': [], 'raw': '"shared"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 229: {'name': 'COLLAPSE_CLAUSE', 'pattern': {'value': 'collapse', 'flags': [], 'raw': '"collapse"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 230: {'name': 'LASTPRIVATE_CLAUSE', 'pattern': {'value': 'lastprivate', 'flags': [], 'raw': '"lastprivate"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 231: {'name': 'CONDITIONAL', 'pattern': {'value': 'conditional', 'flags': [], 'raw': '"conditional"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 232: {'name': 'ALLOCATE_CLAUSE', 'pattern': {'value': 'allocate', 'flags': [], 'raw': '"allocate"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 233: {'name': 'NOWAIT_CLAUSE', 'pattern': {'value': 'nowait', 'flags': [], 'raw': '"nowait"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 234: {'name': 'FINAL_CLAUSE', 'pattern': {'value': 'final', 'flags': [], 'raw': '"final"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 235: {'name': 'MERGEABLE_CLAUSE', 'pattern': {'value': 'mergeable', 'flags': [], 'raw': '"mergeable"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 236: {'name': 'UNTIED_CLAUSE', 'pattern': {'value': 'untied', 'flags': [], 'raw': '"untied"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 237: {'name': 'AFFINITY_CLAUSE', 'pattern': {'value': 'affinity', 'flags': [], 'raw': '"affinity"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 238: {'name': 'DETACH_CLAUSE', 'pattern': {'value': 'detach', 'flags': [], 'raw': '"detach"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 239: {'name': 'IN_REDUCTION_CLAUSE', 'pattern': {'value': 'in_reduction', 'flags': [], 'raw': '"in_reduction"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 240: {'name': 'PRIORITY_CLAUSE', 'pattern': {'value': 'priority', 'flags': [], 'raw': '"priority"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 241: {'name': 'REPLAYABLE_CLAUSE', 'pattern': {'value': 'replayable', 'flags': [], 'raw': '"replayable"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 242: {'name': 'THREADSET_CLAUSE', 'pattern': {'value': 'threadset', 'flags': [], 'raw': '"threadset"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 243: {'name': 'OMP_POOL', 'pattern': {'value': 'omp_pool', 'flags': [], 'raw': '"omp_pool"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 244: {'name': 'OMP_TEAM', 'pattern': {'value': 'omp_team', 'flags': [], 'raw': '"omp_team"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 245: {'name': 'TRANSPARENT_CLAUSE', 'pattern': {'value': 'transparent', 'flags': [], 'raw': '"transparent"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 246: {'name': 'NOGROUP_CLAUSE', 'pattern': {'value': 'nogroup', 'flags': [], 'raw': '"nogroup"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 247: {'name': 'MAP_CLAUSE', 'pattern': {'value': 'map', 'flags': [], 'raw': '"map"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 248: {'name': 'ALWAYS', 'pattern': {'value': 'always', 'flags': [], 'raw': '"always"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 249: {'name': 'CLOSE', 'pattern': {'value': 'close', 'flags': [], 'raw': '"close"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 250: {'name': 'PRESENT', 'pattern': {'value': 'present', 'flags': [], 'raw': '"present"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 251: {'name': 'SELF', 'pattern': {'value': 'self', 'flags': [], 'raw': '"self"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 252: {'name': 'REF_PTEE', 'pattern': {'value': 'ref_ptee', 'flags': [], 'raw': '"ref_ptee"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 253: {'name': 'REF_PTR', 'pattern': {'value': 'ref_ptr', 'flags': [], 'raw': '"ref_ptr"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 254: {'name': 'REF_PTR_PTEE', 'pattern': {'value': 'ref_ptr_ptee', 'flags': [], 'raw': '"ref_ptr_ptee"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 255: {'name': 'DELETE', 'pattern': {'value': 'delete', 'flags': [], 'raw': '"delete"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 256: {'name': 'FROM', 'pattern': {'value': 'from', 'flags': [], 'raw': '"from"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 257: {'name': 'STORAGE', 'pattern': {'value': 'storage', 'flags': [], 'raw': '"storage"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 258: {'name': 'TO', 'pattern': {'value': 'to', 'flags': [], 'raw': '"to"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 259: {'name': 'TOFROM', 'pattern': {'value': 'tofrom', 'flags': [], 'raw': '"tofrom"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 260: {'name': 'PY_CODE_OUT', 'pattern': {'value': '[^(){}\\[\\]:,]+', 'flags': [], 'raw': '/[^(){}\\[\\]:,]+/', '_width': [1, 18446744073709551616], '__type__': 'PatternRE'}, 'priority': -1, '__type__': 'TerminalDef'}, 261: {'name': 'PY_CODE_IN', 'pattern': {'value': '[^(){}\\[\\]]+', 'flags': [], 'raw': '/[^(){}\\[\\]]+/', '_width': [1, 18446744073709551616], '__type__': 'PatternRE'}, 'priority': -1, '__type__': 'TerminalDef'}, 262: {'name': 'PLUS', 'pattern': {'value': '+', 'flags': [], 'raw': '"+"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 263: {'name': 'MULT', 'pattern': {'value': '*', 'flags': [], 'raw': '"*"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 264: {'name': 'BITWISE_AND', 'pattern': {'value': '&', 'flags': [], 'raw': '"&"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 265: {'name': 'BITWISE_OR', 'pattern': {'value': '|', 'flags': [], 'raw': '"|"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 266: {'name': 'BITWISE_XOR', 'pattern': {'value': '^', 'flags': [], 'raw': '"^"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 267: {'name': 'LOGIC_AND', 'pattern': {'value': 'and', 'flags': [], 'raw': '"and"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 268: {'name': 'LOGIC_OR', 'pattern': {'value': 'or', 'flags': [], 'raw': '"or"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 269: {'name': 'MAX', 'pattern': {'value': 'max', 'flags': [], 'raw': '"max"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 270: {'name': 'MIN', 'pattern': {'value': 'min', 'flags': [], 'raw': '"min"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 271: {'name': 'ORIGINAL', 'pattern': {'value': 'original', 'flags': [], 'raw': '"original"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 272: {'name': 'ITERATOR', 'pattern': {'value': 'iterator', 'flags': [], 'raw': '"iterator"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 273: {'name': 'STEP', 'pattern': {'value': 'step', 'flags': [], 'raw': '"step"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 274: {'name': 'ALLOCATOR', 'pattern': {'value': 'allocator', 'flags': [], 'raw': '"allocator"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 275: {'name': 'ALIGN', 'pattern': {'value': 'align', 'flags': [], 'raw': '"align"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 276: {'name': 'MAPPER', 'pattern': {'value': 'mapper', 'flags': [], 'raw': '"mapper"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 277: {'name': 'MEMSPACE', 'pattern': {'value': 'memspace', 'flags': [], 'raw': '"memspace"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 278: {'name': 'TRAITS', 'pattern': {'value': 'traits', 'flags': [], 'raw': '"traits"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 279: {'name': 'FUSED', 'pattern': {'value': 'fused', 'flags': [], 'raw': '"fused"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 280: {'name': 'GRID', 'pattern': {'value': 'grid', 'flags': [], 'raw': '"grid"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 281: {'name': 'IDENTITY', 'pattern': {'value': 'identity', 'flags': [], 'raw': '"identity"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 282: {'name': 'INTERCHANGED', 'pattern': {'value': 'interchanged', 'flags': [], 'raw': '"interchanged"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 283: {'name': 'INTRATILE', 'pattern': {'value': 'intratile', 'flags': [], 'raw': '"intratile"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 284: {'name': 'OFFSETS', 'pattern': {'value': 'offsets', 'flags': [], 'raw': '"offsets"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 285: {'name': 'REVERSED', 'pattern': {'value': 'reversed', 'flags': [], 'raw': '"reversed"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 286: {'name': 'SPLIT', 'pattern': {'value': 'split', 'flags': [], 'raw': '"split"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 287: {'name': 'UNROLLED', 'pattern': {'value': 'unrolled', 'flags': [], 'raw': '"unrolled"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 288: {'name': 'PREFER_TYPE', 'pattern': {'value': 'prefer_type', 'flags': [], 'raw': '"prefer_type"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 289: {'name': 'FR', 'pattern': {'value': 'fr', 'flags': [], 'raw': '"fr"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 290: {'name': 'ATTR', 'pattern': {'value': 'attr', 'flags': [], 'raw': '"attr"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 291: {'name': '_WHITESPACE', 'pattern': {'value': '\\s+', 'flags': [], 'raw': '/\\s+/', '_width': [1, 18446744073709551616], '__type__': 'PatternRE'}, 'priority': 0, '__type__': 'TerminalDef'}, 292: {'name': 'INTEGER', 'pattern': {'value': '(?:0(?:x|X)(?:(?:_)?(?:[0-9]|[a-f]|[A-F]))+|0(?:b|B)(?:(?:_)?(?:0|1))+|0(?:o|O)(?:(?:_)?[0-7])+|[1-9](?:(?:_)?[0-9])*|(?:0)+(?:(?:_)?0)*)', 'flags': [], 'raw': None, '_width': [1, 18446744073709551616], '__type__': 'PatternRE'}, 'priority': 0, '__type__': 'TerminalDef'}, 293: {'name': 'IDENTIFIER', 'pattern': {'value': '[^\\W\\d]\\w*', 'flags': [], 'raw': '/[^\\W\\d]\\w*/', '_width': [1, 18446744073709551616], '__type__': 'PatternRE'}, 'priority': 0, '__type__': 'TerminalDef'}, 294: {'name': 'COMMA', 'pattern': {'value': ',', 'flags': [], 'raw': '","', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 295: {'name': 'LPAR', 'pattern': {'value': '(', 'flags': [], 'raw': '"("', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 296: {'name': 'RPAR', 'pattern': {'value': ')', 'flags': [], 'raw': '")"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 297: {'name': 'COLON', 'pattern': {'value': ':', 'flags': [], 'raw': '":"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 298: {'name': 'LBRACE', 'pattern': {'value': '{', 'flags': [], 'raw': '"{"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 299: {'name': 'RBRACE', 'pattern': {'value': '}', 'flags': [], 'raw': '"}"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 300: {'name': 'LSQB', 'pattern': {'value': '[', 'flags': [], 'raw': '"["', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 301: {'name': 'RSQB', 'pattern': {'value': ']', 'flags': [], 'raw': '"]"', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 302: {'name': 'EQUAL', 'pattern': {'value': '=', 'flags': [], 'raw': '"="', '__type__': 'PatternStr'}, 'priority': 0, '__type__': 'TerminalDef'}, 303: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'threadprivate_directive', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 304: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'declare_reduction_directive', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 305: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'declare_reduction_directive6', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 306: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'declare_induction_directive', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 307: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'scan_directive', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 308: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'declare_mapper_directive', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 309: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'groupprivate_directive', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 310: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'allocate_directive', '__type__': 'NonTerminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 311: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'metadirective_directive', '__type__': 'NonTerminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 312: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'declare_variant_directive', '__type__': 'NonTerminal'}], 'order': 9, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 313: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'dispatch_directive', '__type__': 'NonTerminal'}], 'order': 10, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 314: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'declare_simd_directive', '__type__': 'NonTerminal'}], 'order': 11, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 315: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'declare_target_directive', '__type__': 'NonTerminal'}], 'order': 12, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 316: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'requires_directive', '__type__': 'NonTerminal'}], 'order': 13, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 317: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'assume_directive', '__type__': 'NonTerminal'}], 'order': 14, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 318: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nothing_directive', '__type__': 'NonTerminal'}], 'order': 15, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 319: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'error_directive', '__type__': 'NonTerminal'}], 'order': 16, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 320: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'fuse_directive', '__type__': 'NonTerminal'}], 'order': 17, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 321: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'interchange_directive', '__type__': 'NonTerminal'}], 'order': 18, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 322: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'split_directive', '__type__': 'NonTerminal'}], 'order': 19, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 323: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'stripe_directive', '__type__': 'NonTerminal'}], 'order': 20, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 324: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'tile_directive', '__type__': 'NonTerminal'}], 'order': 21, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 325: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'unroll_directive', '__type__': 'NonTerminal'}], 'order': 22, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 326: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'parallel_directive', '__type__': 'NonTerminal'}], 'order': 23, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 327: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'teams_directive', '__type__': 'NonTerminal'}], 'order': 24, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 328: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'simd_directive', '__type__': 'NonTerminal'}], 'order': 25, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 329: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'masked_directive', '__type__': 'NonTerminal'}], 'order': 26, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 330: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'single_directive', '__type__': 'NonTerminal'}], 'order': 27, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 331: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'scope_directive', '__type__': 'NonTerminal'}], 'order': 28, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 332: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'sections_directive', '__type__': 'NonTerminal'}], 'order': 29, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 333: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'section_directive', '__type__': 'NonTerminal'}], 'order': 30, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 334: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'workshare_directive', '__type__': 'NonTerminal'}], 'order': 31, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 335: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'workdistribute_directive', '__type__': 'NonTerminal'}], 'order': 32, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 336: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'for_directive', '__type__': 'NonTerminal'}], 'order': 33, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 337: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'distribute_directive', '__type__': 'NonTerminal'}], 'order': 34, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 338: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'loop_directive', '__type__': 'NonTerminal'}], 'order': 35, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 339: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'task_directive', '__type__': 'NonTerminal'}], 'order': 36, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 340: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'taskloop_directive', '__type__': 'NonTerminal'}], 'order': 37, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 341: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'task_iteration_directive', '__type__': 'NonTerminal'}], 'order': 38, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 342: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'taskyield_directive', '__type__': 'NonTerminal'}], 'order': 39, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 343: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'taskgraph_directive', '__type__': 'NonTerminal'}], 'order': 40, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 344: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'target_data_directive', '__type__': 'NonTerminal'}], 'order': 41, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 345: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'target_enter_data_directive', '__type__': 'NonTerminal'}], 'order': 42, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 346: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'target_exit_data_directive', '__type__': 'NonTerminal'}], 'order': 43, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 347: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'target_directive', '__type__': 'NonTerminal'}], 'order': 44, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 348: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'target_update_directive', '__type__': 'NonTerminal'}], 'order': 45, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 349: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'interop_directive', '__type__': 'NonTerminal'}], 'order': 46, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 350: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'critical_directive', '__type__': 'NonTerminal'}], 'order': 47, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 351: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'barrier_directive', '__type__': 'NonTerminal'}], 'order': 48, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 352: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'taskgroup_directive', '__type__': 'NonTerminal'}], 'order': 49, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 353: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'taskwait_directive', '__type__': 'NonTerminal'}], 'order': 50, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 354: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'atomic_directive', '__type__': 'NonTerminal'}], 'order': 51, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 355: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'flush_directive', '__type__': 'NonTerminal'}], 'order': 52, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 356: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'depobj_directive', '__type__': 'NonTerminal'}], 'order': 53, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 357: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ordered_directive', '__type__': 'NonTerminal'}], 'order': 54, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 358: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'cancel_directive', '__type__': 'NonTerminal'}], 'order': 55, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 359: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'cancellation_point_directive', '__type__': 'NonTerminal'}], 'order': 56, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 360: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'combined_directive', '__type__': 'NonTerminal'}], 'order': 57, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 361: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'THREADPRIVATE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 362: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DECLARE_REDUCTION_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 363: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DECLARE_INDUCTION_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 364: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SCAN_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 365: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DECLARE_MAPPER_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 366: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'GROUPPRIVATE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 367: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ALLOCATE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 368: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'METADIRECTIVE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 369: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DECLARE_VARIANT_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 370: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DISPATCH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 9, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 371: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DECLARE_SIMD_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 10, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 372: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DECLARE_TARGET_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 11, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 373: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'REQUIRES_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 12, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 374: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ASSUME_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 13, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 375: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NOTHING_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 14, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 376: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ERROR_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 15, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 377: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FUSE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 16, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 378: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INTERCHANGE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 17, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 379: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SPLIT_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 18, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 380: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'STRIPE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 19, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 381: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TILE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 20, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 382: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UNROLL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 21, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 383: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PARALLEL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 22, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 384: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TEAMS_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 23, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 385: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SIMD_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 24, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 386: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MASKED_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 25, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 387: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SINGLE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 26, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 388: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SCOPE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 27, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 389: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SECTIONS_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 28, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 390: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SECTION_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 29, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 391: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'WORKSHARE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 30, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 392: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'WORKDISTRIBUTE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 31, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 393: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FOR_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 32, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 394: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DISTRIBUTE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 33, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 395: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LOOP_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 34, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 396: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASK_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 35, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 397: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASKLOOP_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 36, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 398: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASK_ITERATION_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 37, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 399: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASKYIELD_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 38, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 400: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASKGRAPH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 39, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 401: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET_DATA_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 40, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 402: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET_ENTER_DATA_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 41, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 403: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET_EXIT_DATA_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 42, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 404: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 43, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 405: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET_UPDATE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 44, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 406: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INTEROP_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 45, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 407: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CRITICAL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 46, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 408: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'BARRIER_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 47, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 409: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASKGROUP_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 48, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 410: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASKWAIT_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 49, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 411: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ATOMIC_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 50, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 412: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FLUSH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 51, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 413: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEPOBJ_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 52, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 414: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ORDERED_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 53, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 415: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CANCEL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 54, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 416: {'origin': {'name': 'directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CANCELLATION_POINT_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 55, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 417: {'origin': {'name': 'combined_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_combined_directive_name', '__type__': 'NonTerminal'}, {'name': '__combined_directive_plus_0', '__type__': 'NonTerminal'}, {'name': 'combined_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 418: {'origin': {'name': 'combined_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_combined_directive_name', '__type__': 'NonTerminal'}, {'name': '__combined_directive_plus_0', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 419: {'origin': {'name': '_combined_directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PARALLEL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 420: {'origin': {'name': '_combined_directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TEAMS_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 421: {'origin': {'name': '_combined_directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SIMD_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 422: {'origin': {'name': '_combined_directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MASKED_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 423: {'origin': {'name': '_combined_directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SINGLE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 424: {'origin': {'name': '_combined_directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SECTIONS_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 425: {'origin': {'name': '_combined_directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'WORKSHARE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 426: {'origin': {'name': '_combined_directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'WORKDISTRIBUTE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 427: {'origin': {'name': '_combined_directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FOR_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 428: {'origin': {'name': '_combined_directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DISTRIBUTE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 9, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 429: {'origin': {'name': '_combined_directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LOOP_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 10, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 430: {'origin': {'name': '_combined_directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASK_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 11, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 431: {'origin': {'name': '_combined_directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASKLOOP_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 12, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 432: {'origin': {'name': '_combined_directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET_DATA_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 13, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 433: {'origin': {'name': '_combined_directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET_ENTER_DATA_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 14, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 434: {'origin': {'name': '_combined_directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET_EXIT_DATA_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 15, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 435: {'origin': {'name': '_combined_directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 16, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 436: {'origin': {'name': '_combined_directive_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET_UPDATE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 17, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 437: {'origin': {'name': 'combined_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_combined_clause', '__type__': 'NonTerminal'}, {'name': '__combined_clause_list_star_1', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 438: {'origin': {'name': 'combined_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_combined_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 439: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'allocate_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 440: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'copyin_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 441: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'default_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 442: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'firstprivate_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 443: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'if_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 444: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'message_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 445: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'num_threads_clause', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 446: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'private_clause', '__type__': 'NonTerminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 447: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'proc_bind_clause', '__type__': 'NonTerminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 448: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'reduction_clause', '__type__': 'NonTerminal'}], 'order': 9, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 449: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'safesync_clause', '__type__': 'NonTerminal'}], 'order': 10, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 450: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'severity_clause', '__type__': 'NonTerminal'}], 'order': 11, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 451: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'shared_clause', '__type__': 'NonTerminal'}], 'order': 12, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 452: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'num_teams_clause', '__type__': 'NonTerminal'}], 'order': 13, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 453: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'thread_limit_clause', '__type__': 'NonTerminal'}], 'order': 14, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 454: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'aligned_clause', '__type__': 'NonTerminal'}], 'order': 15, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 455: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'collapse_clause', '__type__': 'NonTerminal'}], 'order': 16, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 456: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'induction_clause', '__type__': 'NonTerminal'}], 'order': 17, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 457: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'lastprivate_clause', '__type__': 'NonTerminal'}], 'order': 18, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 458: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'linear_clause', '__type__': 'NonTerminal'}], 'order': 19, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 459: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nontemporal_clause', '__type__': 'NonTerminal'}], 'order': 20, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 460: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'order_clause', '__type__': 'NonTerminal'}], 'order': 21, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 461: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'safelen_clause', '__type__': 'NonTerminal'}], 'order': 22, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 462: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'simdlen_clause', '__type__': 'NonTerminal'}], 'order': 23, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 463: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'filter_clause', '__type__': 'NonTerminal'}], 'order': 24, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 464: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'copyprivate_clause', '__type__': 'NonTerminal'}], 'order': 25, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 465: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nowait_clause', '__type__': 'NonTerminal'}], 'order': 26, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 466: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ordered_clause', '__type__': 'NonTerminal'}], 'order': 27, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 467: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'schedule_clause', '__type__': 'NonTerminal'}], 'order': 28, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 468: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'dist_schedule_clause', '__type__': 'NonTerminal'}], 'order': 29, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 469: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'bind_clause', '__type__': 'NonTerminal'}], 'order': 30, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 470: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'affinity_clause', '__type__': 'NonTerminal'}], 'order': 31, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 471: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'depend_clause', '__type__': 'NonTerminal'}], 'order': 32, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 472: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'detach_clause', '__type__': 'NonTerminal'}], 'order': 33, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 473: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'final_clause', '__type__': 'NonTerminal'}], 'order': 34, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 474: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'in_reduction_clause', '__type__': 'NonTerminal'}], 'order': 35, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 475: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'mergeable_clause', '__type__': 'NonTerminal'}], 'order': 36, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 476: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'priority_clause', '__type__': 'NonTerminal'}], 'order': 37, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 477: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'replayable_clause', '__type__': 'NonTerminal'}], 'order': 38, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 478: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'threadset_clause', '__type__': 'NonTerminal'}], 'order': 39, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 479: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'transparent_clause', '__type__': 'NonTerminal'}], 'order': 40, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 480: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'untied_clause', '__type__': 'NonTerminal'}], 'order': 41, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 481: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'grainsize_clause', '__type__': 'NonTerminal'}], 'order': 42, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 482: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nogroup_clause', '__type__': 'NonTerminal'}], 'order': 43, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 483: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'num_tasks_clause', '__type__': 'NonTerminal'}], 'order': 44, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 484: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'device_clause', '__type__': 'NonTerminal'}], 'order': 45, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 485: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'map_clause', '__type__': 'NonTerminal'}], 'order': 46, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 486: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'use_device_ptr_clause', '__type__': 'NonTerminal'}], 'order': 47, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 487: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'use_device_addr_clause', '__type__': 'NonTerminal'}], 'order': 48, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 488: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'defaultmap_clause', '__type__': 'NonTerminal'}], 'order': 49, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 489: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'device_type_clause', '__type__': 'NonTerminal'}], 'order': 50, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 490: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'has_device_addr_clause', '__type__': 'NonTerminal'}], 'order': 51, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 491: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'is_device_ptr_clause', '__type__': 'NonTerminal'}], 'order': 52, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 492: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'uses_allocators_clause', '__type__': 'NonTerminal'}], 'order': 53, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 493: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'from_clause', '__type__': 'NonTerminal'}], 'order': 54, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 494: {'origin': {'name': '_combined_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'to_clause', '__type__': 'NonTerminal'}], 'order': 55, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 495: {'origin': {'name': 'threadprivate_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'THREADPRIVATE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 496: {'origin': {'name': 'declare_reduction_directive6', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DECLARE_REDUCTION_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'reduction_op', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'type_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_declare_reduction_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 497: {'origin': {'name': 'declare_reduction_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DECLARE_REDUCTION_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'reduction_op', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'type_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_stmt', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'initializer_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 498: {'origin': {'name': 'declare_reduction_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DECLARE_REDUCTION_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'reduction_op', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'type_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_stmt', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, False, False, False, False, False, False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 499: {'origin': {'name': '_declare_reduction_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'combiner_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 500: {'origin': {'name': '_declare_reduction_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'combiner_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'initializer_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 501: {'origin': {'name': '_declare_reduction_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'combiner_clause', '__type__': 'NonTerminal'}, {'name': 'initializer_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 502: {'origin': {'name': '_declare_reduction_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'initializer_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'combiner_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 503: {'origin': {'name': '_declare_reduction_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'initializer_clause', '__type__': 'NonTerminal'}, {'name': 'combiner_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 504: {'origin': {'name': 'combiner_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMBINER_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_stmt', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 505: {'origin': {'name': 'combiner_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMBINER_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_stmt', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 506: {'origin': {'name': 'initializer_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INITIALIZER_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_stmt', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 507: {'origin': {'name': 'initializer_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INITIALIZER_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_stmt', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 508: {'origin': {'name': 'declare_induction_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DECLARE_INDUCTION_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'induction_op', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'type_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_declare_induction_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 509: {'origin': {'name': '_declare_induction_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'collector_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'inductor_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 510: {'origin': {'name': '_declare_induction_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'collector_clause', '__type__': 'NonTerminal'}, {'name': 'inductor_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 511: {'origin': {'name': '_declare_induction_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'inductor_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'collector_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 512: {'origin': {'name': '_declare_induction_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'inductor_clause', '__type__': 'NonTerminal'}, {'name': 'collector_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 513: {'origin': {'name': 'inductor_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INDUCTOR_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_stmt', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 514: {'origin': {'name': 'inductor_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INDUCTOR_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_stmt', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 515: {'origin': {'name': 'collector_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COLLECTOR_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 516: {'origin': {'name': 'collector_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COLLECTOR_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 517: {'origin': {'name': 'scan_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SCAN_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_scan_clauses', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 518: {'origin': {'name': '_scan_clauses', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'exclusive_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 519: {'origin': {'name': '_scan_clauses', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'inclusive_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 520: {'origin': {'name': '_scan_clauses', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'init_complete_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 521: {'origin': {'name': 'exclusive_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'EXCLUSIVE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 522: {'origin': {'name': 'exclusive_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'EXCLUSIVE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 523: {'origin': {'name': 'inclusive_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INCLUSIVE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 524: {'origin': {'name': 'inclusive_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INCLUSIVE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 525: {'origin': {'name': 'init_complete_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INIT_COMPLETE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 526: {'origin': {'name': 'init_complete_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INIT_COMPLETE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 527: {'origin': {'name': 'init_complete_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INIT_COMPLETE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 528: {'origin': {'name': 'declare_mapper_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DECLARE_MAPPER_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_type', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '__declare_mapper_directive_plus_2', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 529: {'origin': {'name': 'declare_mapper_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DECLARE_MAPPER_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_type', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '__declare_mapper_directive_plus_2', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False, False, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 530: {'origin': {'name': 'groupprivate_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'GROUPPRIVATE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'device_type_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 531: {'origin': {'name': 'groupprivate_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'GROUPPRIVATE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 532: {'origin': {'name': 'device_type_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEVICE_TYPE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'device_type_kind', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 533: {'origin': {'name': 'device_type_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEVICE_TYPE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'device_type_kind', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 534: {'origin': {'name': 'device_type_kind', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'HOST', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 535: {'origin': {'name': 'device_type_kind', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NOHOST', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 536: {'origin': {'name': 'device_type_kind', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ANY', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 537: {'origin': {'name': 'allocate_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ALLOCATE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_allocate_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 538: {'origin': {'name': 'allocate_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ALLOCATE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 539: {'origin': {'name': '_allocate_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_allocate_clause', '__type__': 'NonTerminal'}, {'name': '___allocate_clause_list_star_3', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 540: {'origin': {'name': '_allocate_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_allocate_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 541: {'origin': {'name': '_allocate_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'align_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 542: {'origin': {'name': '_allocate_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'allocator_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 543: {'origin': {'name': 'align_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ALIGN_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 544: {'origin': {'name': 'align_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ALIGN_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 545: {'origin': {'name': 'allocator_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ALLOCATOR_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 546: {'origin': {'name': 'allocator_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ALLOCATOR_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 547: {'origin': {'name': 'metadirective_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'METADIRECTIVE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_metadirective_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 548: {'origin': {'name': 'metadirective_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'METADIRECTIVE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 549: {'origin': {'name': '_metadirective_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'when_clause', '__type__': 'NonTerminal'}, {'name': '___metadirective_clause_list_star_4', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'otherwise_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 550: {'origin': {'name': '_metadirective_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'when_clause', '__type__': 'NonTerminal'}, {'name': '___metadirective_clause_list_star_4', '__type__': 'NonTerminal'}, {'name': 'otherwise_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 551: {'origin': {'name': '_metadirective_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'when_clause', '__type__': 'NonTerminal'}, {'name': '___metadirective_clause_list_star_4', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 552: {'origin': {'name': '_metadirective_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'when_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'otherwise_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 553: {'origin': {'name': '_metadirective_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'when_clause', '__type__': 'NonTerminal'}, {'name': 'otherwise_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 554: {'origin': {'name': '_metadirective_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'when_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 555: {'origin': {'name': 'when_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'WHEN_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_when_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'start', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 556: {'origin': {'name': '_when_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 557: {'origin': {'name': '_when_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'context_selector', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 558: {'origin': {'name': '_when_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'context_selector', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 559: {'origin': {'name': '_when_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'context_selector', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 560: {'origin': {'name': 'otherwise_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'OTHERWISE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'start', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 561: {'origin': {'name': 'otherwise_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'OTHERWISE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'start', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 562: {'origin': {'name': 'otherwise_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'OTHERWISE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 563: {'origin': {'name': 'declare_variant_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DECLARE_VARIANT_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_declare_variant_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 564: {'origin': {'name': 'declare_variant_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DECLARE_VARIANT_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_declare_variant_clause_list', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 565: {'origin': {'name': '_declare_variant_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_declare_variant_clause', '__type__': 'NonTerminal'}, {'name': '___declare_variant_clause_list_star_5', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 566: {'origin': {'name': '_declare_variant_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_declare_variant_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 567: {'origin': {'name': '_declare_variant_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'adjust_args_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 568: {'origin': {'name': '_declare_variant_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'append_args_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 569: {'origin': {'name': '_declare_variant_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'match_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 570: {'origin': {'name': 'adjust_args_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ADJUST_ARGS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_adjust_args_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 571: {'origin': {'name': '_adjust_args_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'adjust_op_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 572: {'origin': {'name': '_adjust_args_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'adjust_op_name', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 573: {'origin': {'name': '_adjust_args_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'adjust_op_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 574: {'origin': {'name': 'adjust_op_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NEED_DEVICE_PTR', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 575: {'origin': {'name': 'adjust_op_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NEED_DEVICE_ADDR', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 576: {'origin': {'name': 'adjust_op_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NOTHING', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 577: {'origin': {'name': 'append_args_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'APPEND_ARGS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'append_args_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 578: {'origin': {'name': 'append_args_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'APPEND_ARGS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'append_args_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 579: {'origin': {'name': 'append_args_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'append_op', '__type__': 'NonTerminal'}, {'name': '__append_args_arg_star_6', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 580: {'origin': {'name': 'append_args_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'append_op', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 581: {'origin': {'name': 'append_op', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INTEROP', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'interop_type', '__type__': 'NonTerminal'}, {'name': '__append_op_star_7', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 582: {'origin': {'name': 'append_op', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INTEROP', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'interop_type', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 583: {'origin': {'name': 'interop_type', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 584: {'origin': {'name': 'interop_type', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGETSYNC', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 585: {'origin': {'name': 'match_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MATCH_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'context_selector', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 586: {'origin': {'name': 'match_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MATCH_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'context_selector', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 587: {'origin': {'name': 'dispatch_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DISPATCH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_dispatch_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 588: {'origin': {'name': 'dispatch_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DISPATCH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 589: {'origin': {'name': '_dispatch_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_dispatch_clause', '__type__': 'NonTerminal'}, {'name': '___dispatch_clause_list_star_8', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 590: {'origin': {'name': '_dispatch_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_dispatch_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 591: {'origin': {'name': '_dispatch_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'depend_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 592: {'origin': {'name': '_dispatch_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'device_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 593: {'origin': {'name': '_dispatch_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'interop_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 594: {'origin': {'name': '_dispatch_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'is_device_ptr_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 595: {'origin': {'name': '_dispatch_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'has_device_addr_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 596: {'origin': {'name': '_dispatch_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nocontext_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 597: {'origin': {'name': '_dispatch_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'novariants_clause', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 598: {'origin': {'name': '_dispatch_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nowait_clause', '__type__': 'NonTerminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 599: {'origin': {'name': 'interop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INTEROP_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 600: {'origin': {'name': 'interop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INTEROP_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 601: {'origin': {'name': 'is_device_ptr_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'IS_DEVICE_PTR_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 602: {'origin': {'name': 'is_device_ptr_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'IS_DEVICE_PTR_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 603: {'origin': {'name': 'has_device_addr_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'HAS_DEVICE_ADDR_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 604: {'origin': {'name': 'has_device_addr_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'HAS_DEVICE_ADDR_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 605: {'origin': {'name': 'nocontext_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NOCONTEXT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 606: {'origin': {'name': 'nocontext_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NOCONTEXT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 607: {'origin': {'name': 'novariants_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NOVARIANTS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 608: {'origin': {'name': 'novariants_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NOVARIANTS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 609: {'origin': {'name': 'declare_simd_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DECLARE_SIMD_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_declare_simd_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 610: {'origin': {'name': 'declare_simd_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DECLARE_SIMD_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 611: {'origin': {'name': 'declare_simd_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DECLARE_SIMD_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_declare_simd_clause_list', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 612: {'origin': {'name': 'declare_simd_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DECLARE_SIMD_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 613: {'origin': {'name': '_declare_simd_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_declare_simd_clause', '__type__': 'NonTerminal'}, {'name': '___declare_simd_clause_list_star_9', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 614: {'origin': {'name': '_declare_simd_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_declare_simd_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 615: {'origin': {'name': '_declare_simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'aligned_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 616: {'origin': {'name': '_declare_simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'linear_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 617: {'origin': {'name': '_declare_simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'simdlen_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 618: {'origin': {'name': '_declare_simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'uniform_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 619: {'origin': {'name': '_declare_simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'inbranch_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 620: {'origin': {'name': '_declare_simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'notinbranch_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 621: {'origin': {'name': 'aligned_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ALIGNED_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_aligned_modifier_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 622: {'origin': {'name': 'aligned_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ALIGNED_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 623: {'origin': {'name': '_aligned_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'alignment_modifier', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 624: {'origin': {'name': '_aligned_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'alignment_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 625: {'origin': {'name': '_aligned_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 626: {'origin': {'name': 'alignment_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INTEGER', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 627: {'origin': {'name': 'linear_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LINEAR_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_linear_modifier_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 628: {'origin': {'name': 'linear_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LINEAR_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 629: {'origin': {'name': '_linear_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_linear_modifier', '__type__': 'NonTerminal'}, {'name': '___linear_modifier_list_star_10', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 630: {'origin': {'name': '_linear_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_linear_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 631: {'origin': {'name': '_linear_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'step_simple_modifier', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 632: {'origin': {'name': '_linear_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'step_modifier', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 633: {'origin': {'name': '_linear_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'linear_modifier_name', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 634: {'origin': {'name': '_linear_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 635: {'origin': {'name': 'linear_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'REF', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 636: {'origin': {'name': 'linear_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UVAL', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 637: {'origin': {'name': 'linear_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'VAL', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 638: {'origin': {'name': 'step_simple_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'py_expr', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 639: {'origin': {'name': 'simdlen_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SIMDLEN_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 640: {'origin': {'name': 'simdlen_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SIMDLEN_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 641: {'origin': {'name': 'uniform_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UNIFORM_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 642: {'origin': {'name': 'uniform_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UNIFORM_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 643: {'origin': {'name': 'inbranch_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INBRANCH', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 644: {'origin': {'name': 'inbranch_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INBRANCH', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 645: {'origin': {'name': 'inbranch_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INBRANCH', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 646: {'origin': {'name': 'notinbranch_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NOTINBRANCH', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 647: {'origin': {'name': 'notinbranch_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NOTINBRANCH', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 648: {'origin': {'name': 'notinbranch_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NOTINBRANCH', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 649: {'origin': {'name': 'declare_target_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DECLARE_TARGET_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': 'declare_target_directive', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 650: {'origin': {'name': 'declare_target_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DECLARE_TARGET_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_declare_target_clause_list', '__type__': 'NonTerminal'}], 'order': 1, 'alias': 'declare_target_directive_with_clauses', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 651: {'origin': {'name': '_declare_target_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_declare_target_clause', '__type__': 'NonTerminal'}, {'name': '___declare_target_clause_list_star_11', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 652: {'origin': {'name': '_declare_target_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_declare_target_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 653: {'origin': {'name': '_declare_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'device_type_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 654: {'origin': {'name': '_declare_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'enter_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 655: {'origin': {'name': '_declare_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'indirect_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 656: {'origin': {'name': '_declare_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'link_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 657: {'origin': {'name': '_declare_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'local_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 658: {'origin': {'name': 'enter_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ENTER_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_enter_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 659: {'origin': {'name': 'enter_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ENTER_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 660: {'origin': {'name': '_enter_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'automap_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 661: {'origin': {'name': '_enter_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 662: {'origin': {'name': '_enter_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'automap_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 663: {'origin': {'name': '_enter_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'automap_name', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 664: {'origin': {'name': 'automap_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'AUTOMAP', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 665: {'origin': {'name': 'indirect_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INDIRECT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_type', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 666: {'origin': {'name': 'indirect_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INDIRECT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_type', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 667: {'origin': {'name': 'indirect_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INDIRECT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 668: {'origin': {'name': 'link_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LINK_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 669: {'origin': {'name': 'link_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LINK_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 670: {'origin': {'name': 'local_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LOCAL_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 671: {'origin': {'name': 'local_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LOCAL_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 672: {'origin': {'name': 'requires_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'REQUIRES_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_requires_directive_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 673: {'origin': {'name': '_requires_directive_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_requires_directive_clause', '__type__': 'NonTerminal'}, {'name': '___requires_directive_clause_list_star_12', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 674: {'origin': {'name': '_requires_directive_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_requires_directive_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 675: {'origin': {'name': '_requires_directive_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'atomic_default_mem_order_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 676: {'origin': {'name': '_requires_directive_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'device_safesync_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 677: {'origin': {'name': '_requires_directive_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'dynamic_allocators_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 678: {'origin': {'name': '_requires_directive_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'reverse_offload_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 679: {'origin': {'name': '_requires_directive_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'self_maps_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 680: {'origin': {'name': '_requires_directive_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'unified_address_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 681: {'origin': {'name': '_requires_directive_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'unified_shared_memory_clause', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 682: {'origin': {'name': 'atomic_default_mem_order_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ATOMIC_DEFAULT_MEM_ORDER_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'atomic_default_mem_order_clause_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 683: {'origin': {'name': 'atomic_default_mem_order_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ATOMIC_DEFAULT_MEM_ORDER_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'atomic_default_mem_order_clause_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 684: {'origin': {'name': 'atomic_default_mem_order_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ACQ_REL', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 685: {'origin': {'name': 'atomic_default_mem_order_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ACQUIRE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 686: {'origin': {'name': 'atomic_default_mem_order_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'RELAXED', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 687: {'origin': {'name': 'atomic_default_mem_order_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SEQ_CST', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 688: {'origin': {'name': 'dynamic_allocators_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DYNAMIC_ALLOCATORS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 689: {'origin': {'name': 'dynamic_allocators_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DYNAMIC_ALLOCATORS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 690: {'origin': {'name': 'dynamic_allocators_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DYNAMIC_ALLOCATORS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 691: {'origin': {'name': 'reverse_offload_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'REVERSE_OFFLOAD_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 692: {'origin': {'name': 'reverse_offload_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'REVERSE_OFFLOAD_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 693: {'origin': {'name': 'reverse_offload_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'REVERSE_OFFLOAD_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 694: {'origin': {'name': 'unified_address_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UNIFIED_ADDRESS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 695: {'origin': {'name': 'unified_address_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UNIFIED_ADDRESS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 696: {'origin': {'name': 'unified_address_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UNIFIED_ADDRESS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 697: {'origin': {'name': 'unified_shared_memory_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UNIFIED_SHARED_MEMORY_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 698: {'origin': {'name': 'unified_shared_memory_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UNIFIED_SHARED_MEMORY_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 699: {'origin': {'name': 'unified_shared_memory_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UNIFIED_SHARED_MEMORY_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 700: {'origin': {'name': 'self_maps_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SELF_MAPS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 701: {'origin': {'name': 'self_maps_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SELF_MAPS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 702: {'origin': {'name': 'self_maps_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SELF_MAPS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 703: {'origin': {'name': 'device_safesync_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEVICE_SAFESYNC_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 704: {'origin': {'name': 'device_safesync_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEVICE_SAFESYNC_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 705: {'origin': {'name': 'device_safesync_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEVICE_SAFESYNC_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 706: {'origin': {'name': 'assume_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ASSUME_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_assume_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 707: {'origin': {'name': '_assume_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_assume_clause', '__type__': 'NonTerminal'}, {'name': '___assume_clause_list_star_13', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 708: {'origin': {'name': '_assume_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_assume_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 709: {'origin': {'name': '_assume_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'absent_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 710: {'origin': {'name': '_assume_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'contains_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 711: {'origin': {'name': '_assume_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'holds_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 712: {'origin': {'name': '_assume_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'no_openmp_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 713: {'origin': {'name': '_assume_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'no_openmp_constructs_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 714: {'origin': {'name': '_assume_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'no_openmp_routines_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 715: {'origin': {'name': '_assume_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'no_parallelism_clause', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 716: {'origin': {'name': 'absent_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ABSENT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 717: {'origin': {'name': 'absent_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ABSENT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 718: {'origin': {'name': 'directive_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': '__directive_list_star_14', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 719: {'origin': {'name': 'directive_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 720: {'origin': {'name': 'contains_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CONTAINS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 721: {'origin': {'name': 'contains_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CONTAINS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 722: {'origin': {'name': 'holds_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'HOLDS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 723: {'origin': {'name': 'holds_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'HOLDS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 724: {'origin': {'name': 'no_openmp_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NO_OPENMP_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 725: {'origin': {'name': 'no_openmp_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NO_OPENMP_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 726: {'origin': {'name': 'no_openmp_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NO_OPENMP_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 727: {'origin': {'name': 'no_openmp_constructs_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NO_OPENMP_CONSTRUCTS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 728: {'origin': {'name': 'no_openmp_constructs_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NO_OPENMP_CONSTRUCTS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 729: {'origin': {'name': 'no_openmp_constructs_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NO_OPENMP_CONSTRUCTS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 730: {'origin': {'name': 'no_openmp_routines_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NO_OPENMP_ROUTINES_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 731: {'origin': {'name': 'no_openmp_routines_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NO_OPENMP_ROUTINES_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 732: {'origin': {'name': 'no_openmp_routines_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NO_OPENMP_ROUTINES_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 733: {'origin': {'name': 'no_parallelism_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NO_PARALLELISM_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 734: {'origin': {'name': 'no_parallelism_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NO_PARALLELISM_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 735: {'origin': {'name': 'no_parallelism_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NO_PARALLELISM_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 736: {'origin': {'name': 'nothing_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NOTHING_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'apply_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 737: {'origin': {'name': 'nothing_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NOTHING_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 738: {'origin': {'name': 'error_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ERROR_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_error_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 739: {'origin': {'name': 'error_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ERROR_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 740: {'origin': {'name': '_error_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_error_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_error_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 741: {'origin': {'name': '_error_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_error_clause', '__type__': 'NonTerminal'}, {'name': '_error_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 742: {'origin': {'name': '_error_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_error_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 743: {'origin': {'name': '_error_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'at_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 744: {'origin': {'name': '_error_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'message_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 745: {'origin': {'name': '_error_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'severity_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 746: {'origin': {'name': 'at_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'AT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'at_clause_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 747: {'origin': {'name': 'at_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'AT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'at_clause_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 748: {'origin': {'name': 'at_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMPILATION', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 749: {'origin': {'name': 'at_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'EXECUTION', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 750: {'origin': {'name': 'message_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MESSAGE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 751: {'origin': {'name': 'message_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MESSAGE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 752: {'origin': {'name': 'severity_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SEVERITY_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'severity_clause_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 753: {'origin': {'name': 'severity_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SEVERITY_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'severity_clause_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 754: {'origin': {'name': 'severity_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FATAL', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 755: {'origin': {'name': 'severity_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'WARNING', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 756: {'origin': {'name': 'fuse_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FUSE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'apply_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 757: {'origin': {'name': 'fuse_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FUSE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'looprange_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 758: {'origin': {'name': 'looprange_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LOOPRANGE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 759: {'origin': {'name': 'looprange_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LOOPRANGE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 760: {'origin': {'name': 'interchange_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INTERCHANGE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_interchange_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 761: {'origin': {'name': 'interchange_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INTERCHANGE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 762: {'origin': {'name': '_interchange_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'apply_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 763: {'origin': {'name': '_interchange_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'permutation_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 764: {'origin': {'name': '_interchange_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'apply_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'permutation_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 765: {'origin': {'name': '_interchange_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'apply_clause', '__type__': 'NonTerminal'}, {'name': 'permutation_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 766: {'origin': {'name': '_interchange_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'permutation_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'apply_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 767: {'origin': {'name': '_interchange_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'permutation_clause', '__type__': 'NonTerminal'}, {'name': 'apply_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 768: {'origin': {'name': 'permutation_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PERMUTATION_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'expr_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 769: {'origin': {'name': 'permutation_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PERMUTATION_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'expr_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 770: {'origin': {'name': 'split_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SPLIT_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_split_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 771: {'origin': {'name': '_split_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'counts_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 772: {'origin': {'name': '_split_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'apply_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'counts_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 773: {'origin': {'name': '_split_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'apply_clause', '__type__': 'NonTerminal'}, {'name': 'counts_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 774: {'origin': {'name': '_split_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'counts_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'apply_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 775: {'origin': {'name': '_split_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'counts_clause', '__type__': 'NonTerminal'}, {'name': 'apply_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 776: {'origin': {'name': 'counts_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COUNTS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'expr_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 777: {'origin': {'name': 'counts_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COUNTS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'expr_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 778: {'origin': {'name': 'stripe_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'STRIPE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_stripe_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 779: {'origin': {'name': '_stripe_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'sizes_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 780: {'origin': {'name': '_stripe_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'apply_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'sizes_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 781: {'origin': {'name': '_stripe_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'apply_clause', '__type__': 'NonTerminal'}, {'name': 'sizes_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 782: {'origin': {'name': '_stripe_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'sizes_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'apply_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 783: {'origin': {'name': '_stripe_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'sizes_clause', '__type__': 'NonTerminal'}, {'name': 'apply_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 784: {'origin': {'name': 'sizes_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SIZES_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'expr_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 785: {'origin': {'name': 'sizes_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SIZES_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'expr_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 786: {'origin': {'name': 'tile_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TILE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_tile_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 787: {'origin': {'name': 'tile_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TILE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 788: {'origin': {'name': '_tile_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'sizes_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 789: {'origin': {'name': '_tile_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'apply_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'sizes_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 790: {'origin': {'name': '_tile_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'apply_clause', '__type__': 'NonTerminal'}, {'name': 'sizes_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 791: {'origin': {'name': '_tile_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'sizes_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'apply_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 792: {'origin': {'name': '_tile_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'sizes_clause', '__type__': 'NonTerminal'}, {'name': 'apply_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 793: {'origin': {'name': 'unroll_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UNROLL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_unroll_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 794: {'origin': {'name': 'unroll_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UNROLL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 795: {'origin': {'name': '_unroll_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'full_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 796: {'origin': {'name': '_unroll_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'partial_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 797: {'origin': {'name': '_unroll_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'apply_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 798: {'origin': {'name': '_unroll_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'full_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'apply_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 799: {'origin': {'name': '_unroll_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'full_clause', '__type__': 'NonTerminal'}, {'name': 'apply_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 800: {'origin': {'name': '_unroll_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'apply_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'full_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 801: {'origin': {'name': '_unroll_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'apply_clause', '__type__': 'NonTerminal'}, {'name': 'full_clause', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 802: {'origin': {'name': '_unroll_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'partial_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'apply_clause', '__type__': 'NonTerminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 803: {'origin': {'name': '_unroll_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'partial_clause', '__type__': 'NonTerminal'}, {'name': 'apply_clause', '__type__': 'NonTerminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 804: {'origin': {'name': '_unroll_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'apply_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'partial_clause', '__type__': 'NonTerminal'}], 'order': 9, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 805: {'origin': {'name': '_unroll_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'apply_clause', '__type__': 'NonTerminal'}, {'name': 'partial_clause', '__type__': 'NonTerminal'}], 'order': 10, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 806: {'origin': {'name': 'full_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FULL_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 807: {'origin': {'name': 'full_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FULL_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 808: {'origin': {'name': 'full_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FULL_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 809: {'origin': {'name': 'partial_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PARTIAL_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 810: {'origin': {'name': 'partial_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PARTIAL_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 811: {'origin': {'name': 'partial_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PARTIAL_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 812: {'origin': {'name': 'parallel_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PARALLEL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_parallel_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 813: {'origin': {'name': 'parallel_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PARALLEL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 814: {'origin': {'name': '_parallel_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_parallel_clause', '__type__': 'NonTerminal'}, {'name': '___parallel_clause_list_star_15', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 815: {'origin': {'name': '_parallel_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_parallel_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 816: {'origin': {'name': '_parallel_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'allocate_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 817: {'origin': {'name': '_parallel_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'copyin_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 818: {'origin': {'name': '_parallel_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'default_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 819: {'origin': {'name': '_parallel_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'firstprivate_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 820: {'origin': {'name': '_parallel_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'if_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 821: {'origin': {'name': '_parallel_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'message_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 822: {'origin': {'name': '_parallel_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'num_threads_clause', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 823: {'origin': {'name': '_parallel_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'private_clause', '__type__': 'NonTerminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 824: {'origin': {'name': '_parallel_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'proc_bind_clause', '__type__': 'NonTerminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 825: {'origin': {'name': '_parallel_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'reduction_clause', '__type__': 'NonTerminal'}], 'order': 9, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 826: {'origin': {'name': '_parallel_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'safesync_clause', '__type__': 'NonTerminal'}], 'order': 10, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 827: {'origin': {'name': '_parallel_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'severity_clause', '__type__': 'NonTerminal'}], 'order': 11, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 828: {'origin': {'name': '_parallel_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'shared_clause', '__type__': 'NonTerminal'}], 'order': 12, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 829: {'origin': {'name': 'copyin_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COPYIN_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 830: {'origin': {'name': 'copyin_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COPYIN_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 831: {'origin': {'name': 'num_threads_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NUM_THREADS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_num_threads_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'expr_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 832: {'origin': {'name': 'num_threads_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NUM_THREADS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'expr_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 833: {'origin': {'name': '_num_threads_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'strict_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 834: {'origin': {'name': '_num_threads_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 835: {'origin': {'name': '_num_threads_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'strict_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 836: {'origin': {'name': '_num_threads_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'strict_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 837: {'origin': {'name': 'strict_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'STRICT', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 838: {'origin': {'name': 'proc_bind_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PROC_BIND_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'proc_bind_clause_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 839: {'origin': {'name': 'proc_bind_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PROC_BIND_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'proc_bind_clause_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 840: {'origin': {'name': 'proc_bind_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CLOSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 841: {'origin': {'name': 'proc_bind_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PRIMARY', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 842: {'origin': {'name': 'proc_bind_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SPREAD', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 843: {'origin': {'name': 'safesync_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SAFESYNC_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 844: {'origin': {'name': 'safesync_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SAFESYNC_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 845: {'origin': {'name': 'safesync_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SAFESYNC_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 846: {'origin': {'name': 'teams_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TEAMS_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_teams_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 847: {'origin': {'name': 'teams_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TEAMS_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 848: {'origin': {'name': '_teams_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_teams_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_teams_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 849: {'origin': {'name': '_teams_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_teams_clause', '__type__': 'NonTerminal'}, {'name': '_teams_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 850: {'origin': {'name': '_teams_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_teams_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 851: {'origin': {'name': '_teams_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'allocate_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 852: {'origin': {'name': '_teams_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'default_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 853: {'origin': {'name': '_teams_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'firstprivate_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 854: {'origin': {'name': '_teams_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'if_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 855: {'origin': {'name': '_teams_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'num_teams_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 856: {'origin': {'name': '_teams_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'reduction_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 857: {'origin': {'name': '_teams_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'shared_clause', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 858: {'origin': {'name': '_teams_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'thread_limit_clause', '__type__': 'NonTerminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 859: {'origin': {'name': 'num_teams_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NUM_TEAMS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_num_teams_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 860: {'origin': {'name': 'num_teams_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NUM_TEAMS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 861: {'origin': {'name': '_num_teams_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 862: {'origin': {'name': '_num_teams_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'lower_bound', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 863: {'origin': {'name': '_num_teams_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'lower_bound', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 864: {'origin': {'name': 'lower_bound', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'py_expr', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 865: {'origin': {'name': 'thread_limit_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'THREAD_LIMIT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 866: {'origin': {'name': 'thread_limit_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'THREAD_LIMIT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 867: {'origin': {'name': 'simd_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SIMD_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_simd_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 868: {'origin': {'name': 'simd_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SIMD_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 869: {'origin': {'name': '_simd_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_simd_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_simd_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 870: {'origin': {'name': '_simd_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_simd_clause', '__type__': 'NonTerminal'}, {'name': '_simd_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 871: {'origin': {'name': '_simd_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_simd_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 872: {'origin': {'name': '_simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'aligned_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 873: {'origin': {'name': '_simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'collapse_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 874: {'origin': {'name': '_simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'if_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 875: {'origin': {'name': '_simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'induction_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 876: {'origin': {'name': '_simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'lastprivate_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 877: {'origin': {'name': '_simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'linear_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 878: {'origin': {'name': '_simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nontemporal_clause', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 879: {'origin': {'name': '_simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'order_clause', '__type__': 'NonTerminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 880: {'origin': {'name': '_simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'private_clause', '__type__': 'NonTerminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 881: {'origin': {'name': '_simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'reduction_clause', '__type__': 'NonTerminal'}], 'order': 9, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 882: {'origin': {'name': '_simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'safelen_clause', '__type__': 'NonTerminal'}], 'order': 10, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 883: {'origin': {'name': '_simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'simdlen_clause', '__type__': 'NonTerminal'}], 'order': 11, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 884: {'origin': {'name': 'nontemporal_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NONTEMPORAL_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 885: {'origin': {'name': 'nontemporal_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NONTEMPORAL_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 886: {'origin': {'name': 'order_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ORDER_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_order_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'CONCURRENT', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 887: {'origin': {'name': 'order_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ORDER_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'CONCURRENT', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 888: {'origin': {'name': '_order_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 889: {'origin': {'name': '_order_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'order_modifier_name', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 890: {'origin': {'name': '_order_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'order_modifier_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 891: {'origin': {'name': '_order_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'order_modifier_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 892: {'origin': {'name': 'order_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'REPRODUCIBLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 893: {'origin': {'name': 'order_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UNCONSTRAINED', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 894: {'origin': {'name': 'safelen_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SAFELEN_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 895: {'origin': {'name': 'safelen_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SAFELEN_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 896: {'origin': {'name': 'masked_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MASKED_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'filter_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 897: {'origin': {'name': 'masked_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MASKED_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 898: {'origin': {'name': 'filter_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FILTER_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 899: {'origin': {'name': 'filter_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FILTER_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 900: {'origin': {'name': 'single_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SINGLE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_single_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 901: {'origin': {'name': 'single_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SINGLE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 902: {'origin': {'name': '_single_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_single_clause', '__type__': 'NonTerminal'}, {'name': '___single_clause_list_star_16', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 903: {'origin': {'name': '_single_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_single_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 904: {'origin': {'name': '_single_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'allocate_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 905: {'origin': {'name': '_single_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'copyprivate_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 906: {'origin': {'name': '_single_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'firstprivate_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 907: {'origin': {'name': '_single_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nowait_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 908: {'origin': {'name': '_single_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'private_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 909: {'origin': {'name': 'copyprivate_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COPYPRIVATE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 910: {'origin': {'name': 'copyprivate_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COPYPRIVATE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 911: {'origin': {'name': 'scope_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SCOPE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_scope_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 912: {'origin': {'name': 'scope_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SCOPE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 913: {'origin': {'name': '_scope_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_scope_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_scope_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 914: {'origin': {'name': '_scope_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_scope_clause', '__type__': 'NonTerminal'}, {'name': '_scope_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 915: {'origin': {'name': '_scope_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_scope_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 916: {'origin': {'name': '_scope_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'allocate_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 917: {'origin': {'name': '_scope_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'firstprivate_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 918: {'origin': {'name': '_scope_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nowait_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 919: {'origin': {'name': '_scope_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'private_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 920: {'origin': {'name': '_scope_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'reduction_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 921: {'origin': {'name': 'sections_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SECTIONS_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_sections_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 922: {'origin': {'name': 'sections_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SECTIONS_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 923: {'origin': {'name': '_sections_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_sections_clause', '__type__': 'NonTerminal'}, {'name': '___sections_clause_list_star_17', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 924: {'origin': {'name': '_sections_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_sections_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 925: {'origin': {'name': '_sections_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'allocate_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 926: {'origin': {'name': '_sections_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'firstprivate_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 927: {'origin': {'name': '_sections_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'lastprivate_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 928: {'origin': {'name': '_sections_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nowait_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 929: {'origin': {'name': '_sections_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'private_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 930: {'origin': {'name': '_sections_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'reduction_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 931: {'origin': {'name': 'section_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SECTION_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 932: {'origin': {'name': 'workshare_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'WORKSHARE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'nowait_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 933: {'origin': {'name': 'workshare_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'WORKSHARE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 934: {'origin': {'name': 'workdistribute_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'WORKDISTRIBUTE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 935: {'origin': {'name': 'for_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FOR_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_for_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 936: {'origin': {'name': 'for_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FOR_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 937: {'origin': {'name': '_for_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_for_clause', '__type__': 'NonTerminal'}, {'name': '___for_clause_list_star_18', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 938: {'origin': {'name': '_for_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_for_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 939: {'origin': {'name': '_for_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'allocate_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 940: {'origin': {'name': '_for_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'collapse_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 941: {'origin': {'name': '_for_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'firstprivate_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 942: {'origin': {'name': '_for_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'induction_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 943: {'origin': {'name': '_for_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'lastprivate_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 944: {'origin': {'name': '_for_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'linear_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 945: {'origin': {'name': '_for_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nowait_clause', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 946: {'origin': {'name': '_for_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'order_clause', '__type__': 'NonTerminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 947: {'origin': {'name': '_for_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ordered_clause', '__type__': 'NonTerminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 948: {'origin': {'name': '_for_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'private_clause', '__type__': 'NonTerminal'}], 'order': 9, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 949: {'origin': {'name': '_for_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'reduction_clause', '__type__': 'NonTerminal'}], 'order': 10, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 950: {'origin': {'name': '_for_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'schedule_clause', '__type__': 'NonTerminal'}], 'order': 11, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 951: {'origin': {'name': 'ordered_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ORDERED_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 952: {'origin': {'name': 'ordered_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ORDERED_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 953: {'origin': {'name': 'ordered_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ORDERED_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 954: {'origin': {'name': 'schedule_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SCHEDULE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_schedule_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'schedule_type', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 955: {'origin': {'name': 'schedule_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SCHEDULE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_schedule_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'schedule_type', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, False, False, False, True, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 956: {'origin': {'name': 'schedule_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SCHEDULE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'schedule_type', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 957: {'origin': {'name': 'schedule_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SCHEDULE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'schedule_type', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, False, True, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 958: {'origin': {'name': '_schedule_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_schedule_modifier', '__type__': 'NonTerminal'}, {'name': '___schedule_modifier_list_star_19', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 959: {'origin': {'name': '_schedule_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_schedule_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 960: {'origin': {'name': '_schedule_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ordering_modifier_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 961: {'origin': {'name': '_schedule_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'chunk_modifier_name', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 962: {'origin': {'name': '_schedule_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 963: {'origin': {'name': 'ordering_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MONOTONIC', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 964: {'origin': {'name': 'ordering_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NONMONOTONIC', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 965: {'origin': {'name': 'chunk_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SIMD', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 966: {'origin': {'name': 'schedule_type', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'STATIC', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 967: {'origin': {'name': 'schedule_type', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DYNAMIC', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 968: {'origin': {'name': 'schedule_type', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'GUIDED', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 969: {'origin': {'name': 'schedule_type', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'AUTO', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 970: {'origin': {'name': 'schedule_type', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'RUNTIME', 'filter_out': False, '__type__': 'Terminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 971: {'origin': {'name': 'distribute_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DISTRIBUTE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_distribute_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 972: {'origin': {'name': 'distribute_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DISTRIBUTE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 973: {'origin': {'name': '_distribute_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_distribute_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_distribute_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 974: {'origin': {'name': '_distribute_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_distribute_clause', '__type__': 'NonTerminal'}, {'name': '_distribute_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 975: {'origin': {'name': '_distribute_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_distribute_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 976: {'origin': {'name': '_distribute_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'allocate_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 977: {'origin': {'name': '_distribute_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'collapse_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 978: {'origin': {'name': '_distribute_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'dist_schedule_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 979: {'origin': {'name': '_distribute_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'firstprivate_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 980: {'origin': {'name': '_distribute_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'induction_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 981: {'origin': {'name': '_distribute_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'lastprivate_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 982: {'origin': {'name': '_distribute_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'order_clause', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 983: {'origin': {'name': '_distribute_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'private_clause', '__type__': 'NonTerminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 984: {'origin': {'name': 'dist_schedule_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DIST_SCHEDULE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'STATIC', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 985: {'origin': {'name': 'dist_schedule_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DIST_SCHEDULE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'STATIC', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, False, False, False, True, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 986: {'origin': {'name': 'dist_schedule_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DIST_SCHEDULE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'STATIC', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 987: {'origin': {'name': 'dist_schedule_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DIST_SCHEDULE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'STATIC', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, True, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 988: {'origin': {'name': 'loop_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LOOP_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_loop_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 989: {'origin': {'name': 'loop_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LOOP_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 990: {'origin': {'name': '_loop_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_loop_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_loop_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 991: {'origin': {'name': '_loop_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_loop_clause', '__type__': 'NonTerminal'}, {'name': '_loop_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 992: {'origin': {'name': '_loop_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_loop_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 993: {'origin': {'name': '_loop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'bind_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 994: {'origin': {'name': '_loop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'collapse_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 995: {'origin': {'name': '_loop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'lastprivate_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 996: {'origin': {'name': '_loop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'order_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 997: {'origin': {'name': '_loop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'private_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 998: {'origin': {'name': '_loop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'reduction_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 999: {'origin': {'name': 'bind_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'BIND_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'bind_clause_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1000: {'origin': {'name': 'bind_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'BIND_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'bind_clause_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1001: {'origin': {'name': 'bind_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PARALLEL', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1002: {'origin': {'name': 'bind_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TEAMS', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1003: {'origin': {'name': 'bind_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'THREAD', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1004: {'origin': {'name': 'task_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASK_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_task_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1005: {'origin': {'name': 'task_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASK_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1006: {'origin': {'name': '_task_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_task_clause', '__type__': 'NonTerminal'}, {'name': '___task_clause_list_star_20', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1007: {'origin': {'name': '_task_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_task_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1008: {'origin': {'name': '_task_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'affinity_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1009: {'origin': {'name': '_task_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'allocate_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1010: {'origin': {'name': '_task_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'default_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1011: {'origin': {'name': '_task_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'depend_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1012: {'origin': {'name': '_task_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'detach_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1013: {'origin': {'name': '_task_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'final_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1014: {'origin': {'name': '_task_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'firstprivate_clause', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1015: {'origin': {'name': '_task_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'if_clause', '__type__': 'NonTerminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1016: {'origin': {'name': '_task_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'in_reduction_clause', '__type__': 'NonTerminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1017: {'origin': {'name': '_task_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'mergeable_clause', '__type__': 'NonTerminal'}], 'order': 9, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1018: {'origin': {'name': '_task_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'priority_clause', '__type__': 'NonTerminal'}], 'order': 10, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1019: {'origin': {'name': '_task_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'private_clause', '__type__': 'NonTerminal'}], 'order': 11, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1020: {'origin': {'name': '_task_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'replayable_clause', '__type__': 'NonTerminal'}], 'order': 12, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1021: {'origin': {'name': '_task_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'shared_clause', '__type__': 'NonTerminal'}], 'order': 13, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1022: {'origin': {'name': '_task_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'threadset_clause', '__type__': 'NonTerminal'}], 'order': 14, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1023: {'origin': {'name': '_task_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'transparent_clause', '__type__': 'NonTerminal'}], 'order': 15, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1024: {'origin': {'name': '_task_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'untied_clause', '__type__': 'NonTerminal'}], 'order': 16, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1025: {'origin': {'name': 'taskloop_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASKLOOP_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_taskloop_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1026: {'origin': {'name': 'taskloop_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASKLOOP_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1027: {'origin': {'name': '_taskloop_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_taskloop_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_taskloop_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1028: {'origin': {'name': '_taskloop_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_taskloop_clause', '__type__': 'NonTerminal'}, {'name': '_taskloop_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1029: {'origin': {'name': '_taskloop_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_taskloop_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1030: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'allocate_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1031: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'collapse_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1032: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'default_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1033: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'final_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1034: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'firstprivate_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1035: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'grainsize_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1036: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'if_clause', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1037: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'in_reduction_clause', '__type__': 'NonTerminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1038: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'induction_clause', '__type__': 'NonTerminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1039: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'lastprivate_clause', '__type__': 'NonTerminal'}], 'order': 9, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1040: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'mergeable_clause', '__type__': 'NonTerminal'}], 'order': 10, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1041: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nogroup_clause', '__type__': 'NonTerminal'}], 'order': 11, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1042: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'num_tasks_clause', '__type__': 'NonTerminal'}], 'order': 12, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1043: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'priority_clause', '__type__': 'NonTerminal'}], 'order': 13, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1044: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'private_clause', '__type__': 'NonTerminal'}], 'order': 14, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1045: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'reduction_clause', '__type__': 'NonTerminal'}], 'order': 15, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1046: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'replayable_clause', '__type__': 'NonTerminal'}], 'order': 16, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1047: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'shared_clause', '__type__': 'NonTerminal'}], 'order': 17, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1048: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'threadset_clause', '__type__': 'NonTerminal'}], 'order': 18, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1049: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'transparent_clause', '__type__': 'NonTerminal'}], 'order': 19, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1050: {'origin': {'name': '_taskloop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'untied_clause', '__type__': 'NonTerminal'}], 'order': 20, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1051: {'origin': {'name': 'grainsize_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'GRAINSIZE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_grainsize_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1052: {'origin': {'name': 'grainsize_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'GRAINSIZE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1053: {'origin': {'name': '_grainsize_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'strict_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1054: {'origin': {'name': '_grainsize_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1055: {'origin': {'name': '_grainsize_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'strict_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1056: {'origin': {'name': '_grainsize_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'strict_name', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1057: {'origin': {'name': 'num_tasks_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NUM_TASKS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_num_tasks_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1058: {'origin': {'name': 'num_tasks_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NUM_TASKS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1059: {'origin': {'name': '_num_tasks_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'strict_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1060: {'origin': {'name': '_num_tasks_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1061: {'origin': {'name': '_num_tasks_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'strict_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1062: {'origin': {'name': '_num_tasks_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'strict_name', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1063: {'origin': {'name': 'task_iteration_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASK_ITERATION_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_task_iteration_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1064: {'origin': {'name': '_task_iteration_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_task_iteration_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_task_iteration_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1065: {'origin': {'name': '_task_iteration_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_task_iteration_clause', '__type__': 'NonTerminal'}, {'name': '_task_iteration_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1066: {'origin': {'name': '_task_iteration_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_task_iteration_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1067: {'origin': {'name': '_task_iteration_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'affinity_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1068: {'origin': {'name': '_task_iteration_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'depend_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1069: {'origin': {'name': '_task_iteration_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'if_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1070: {'origin': {'name': 'taskyield_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASKYIELD_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1071: {'origin': {'name': 'taskgraph_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASKGRAPH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_taskgraph_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1072: {'origin': {'name': 'taskgraph_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASKGRAPH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1073: {'origin': {'name': '_taskgraph_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_taskgraph_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_taskgraph_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1074: {'origin': {'name': '_taskgraph_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_taskgraph_clause', '__type__': 'NonTerminal'}, {'name': '_taskgraph_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1075: {'origin': {'name': '_taskgraph_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_taskgraph_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1076: {'origin': {'name': '_taskgraph_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'graph_id_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1077: {'origin': {'name': '_taskgraph_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'graph_reset_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1078: {'origin': {'name': '_taskgraph_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'if_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1079: {'origin': {'name': '_taskgraph_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nogroup_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1080: {'origin': {'name': 'graph_id_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'GRAPH_ID_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1081: {'origin': {'name': 'graph_id_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'GRAPH_ID_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1082: {'origin': {'name': 'graph_reset_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'GRAPH_RESET_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1083: {'origin': {'name': 'graph_reset_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'GRAPH_RESET_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1084: {'origin': {'name': 'target_data_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET_DATA_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_target_data_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1085: {'origin': {'name': '_target_data_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_target_data_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_target_data_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1086: {'origin': {'name': '_target_data_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_target_data_clause', '__type__': 'NonTerminal'}, {'name': '_target_data_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1087: {'origin': {'name': '_target_data_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_target_data_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1088: {'origin': {'name': '_target_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'affinity_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1089: {'origin': {'name': '_target_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'allocate_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1090: {'origin': {'name': '_target_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'default_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1091: {'origin': {'name': '_target_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'depend_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1092: {'origin': {'name': '_target_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'detach_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1093: {'origin': {'name': '_target_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'device_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1094: {'origin': {'name': '_target_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'firstprivate_clause', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1095: {'origin': {'name': '_target_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'if_clause', '__type__': 'NonTerminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1096: {'origin': {'name': '_target_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'in_reduction_clause', '__type__': 'NonTerminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1097: {'origin': {'name': '_target_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'map_clause', '__type__': 'NonTerminal'}], 'order': 9, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1098: {'origin': {'name': '_target_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'mergeable_clause', '__type__': 'NonTerminal'}], 'order': 10, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1099: {'origin': {'name': '_target_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nogroup_clause', '__type__': 'NonTerminal'}], 'order': 11, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1100: {'origin': {'name': '_target_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nowait_clause', '__type__': 'NonTerminal'}], 'order': 12, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1101: {'origin': {'name': '_target_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'priority_clause', '__type__': 'NonTerminal'}], 'order': 13, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1102: {'origin': {'name': '_target_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'private_clause', '__type__': 'NonTerminal'}], 'order': 14, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1103: {'origin': {'name': '_target_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'shared_clause', '__type__': 'NonTerminal'}], 'order': 15, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1104: {'origin': {'name': '_target_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'transparent_clause', '__type__': 'NonTerminal'}], 'order': 16, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1105: {'origin': {'name': '_target_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'use_device_ptr_clause', '__type__': 'NonTerminal'}], 'order': 17, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1106: {'origin': {'name': '_target_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'use_device_addr_clause', '__type__': 'NonTerminal'}], 'order': 18, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1107: {'origin': {'name': 'use_device_ptr_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'USE_DEVICE_PTR_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1108: {'origin': {'name': 'use_device_ptr_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'USE_DEVICE_PTR_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1109: {'origin': {'name': 'use_device_addr_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'USE_DEVICE_ADDR_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1110: {'origin': {'name': 'use_device_addr_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'USE_DEVICE_ADDR_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1111: {'origin': {'name': 'target_enter_data_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET_ENTER_DATA_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_target_enter_data_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1112: {'origin': {'name': 'target_enter_data_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET_ENTER_DATA_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1113: {'origin': {'name': '_target_enter_data_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_target_enter_data_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_target_enter_data_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1114: {'origin': {'name': '_target_enter_data_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_target_enter_data_clause', '__type__': 'NonTerminal'}, {'name': '_target_enter_data_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1115: {'origin': {'name': '_target_enter_data_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_target_enter_data_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1116: {'origin': {'name': '_target_enter_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'depend_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1117: {'origin': {'name': '_target_enter_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'device_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1118: {'origin': {'name': '_target_enter_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'if_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1119: {'origin': {'name': '_target_enter_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'map_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1120: {'origin': {'name': '_target_enter_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nowait_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1121: {'origin': {'name': '_target_enter_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'priority_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1122: {'origin': {'name': '_target_enter_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'replayable_clause', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1123: {'origin': {'name': 'target_exit_data_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET_EXIT_DATA_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_target_exit_data_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1124: {'origin': {'name': 'target_exit_data_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET_EXIT_DATA_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1125: {'origin': {'name': '_target_exit_data_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_target_exit_data_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_target_exit_data_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1126: {'origin': {'name': '_target_exit_data_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_target_exit_data_clause', '__type__': 'NonTerminal'}, {'name': '_target_exit_data_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1127: {'origin': {'name': '_target_exit_data_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_target_exit_data_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1128: {'origin': {'name': '_target_exit_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'depend_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1129: {'origin': {'name': '_target_exit_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'device_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1130: {'origin': {'name': '_target_exit_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'if_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1131: {'origin': {'name': '_target_exit_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'map_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1132: {'origin': {'name': '_target_exit_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nowait_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1133: {'origin': {'name': '_target_exit_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'priority_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1134: {'origin': {'name': '_target_exit_data_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'replayable_clause', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1135: {'origin': {'name': 'target_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_target_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1136: {'origin': {'name': 'target_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1137: {'origin': {'name': '_target_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_target_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_target_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1138: {'origin': {'name': '_target_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_target_clause', '__type__': 'NonTerminal'}, {'name': '_target_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1139: {'origin': {'name': '_target_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_target_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1140: {'origin': {'name': '_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'allocate_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1141: {'origin': {'name': '_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'default_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1142: {'origin': {'name': '_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'defaultmap_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1143: {'origin': {'name': '_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'depend_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1144: {'origin': {'name': '_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'device_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1145: {'origin': {'name': '_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'device_type_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1146: {'origin': {'name': '_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'firstprivate_clause', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1147: {'origin': {'name': '_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'has_device_addr_clause', '__type__': 'NonTerminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1148: {'origin': {'name': '_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'if_clause', '__type__': 'NonTerminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1149: {'origin': {'name': '_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'in_reduction_clause', '__type__': 'NonTerminal'}], 'order': 9, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1150: {'origin': {'name': '_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'is_device_ptr_clause', '__type__': 'NonTerminal'}], 'order': 10, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1151: {'origin': {'name': '_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'map_clause', '__type__': 'NonTerminal'}], 'order': 11, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1152: {'origin': {'name': '_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nowait_clause', '__type__': 'NonTerminal'}], 'order': 12, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1153: {'origin': {'name': '_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'private_clause', '__type__': 'NonTerminal'}], 'order': 13, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1154: {'origin': {'name': '_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'priority_clause', '__type__': 'NonTerminal'}], 'order': 14, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1155: {'origin': {'name': '_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'replayable_clause', '__type__': 'NonTerminal'}], 'order': 15, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1156: {'origin': {'name': '_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'thread_limit_clause', '__type__': 'NonTerminal'}], 'order': 16, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1157: {'origin': {'name': '_target_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'uses_allocators_clause', '__type__': 'NonTerminal'}], 'order': 17, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1158: {'origin': {'name': 'defaultmap_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEFAULTMAP_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_defaultmap_arg', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_defaultmap_modifier_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1159: {'origin': {'name': 'defaultmap_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEFAULTMAP_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_defaultmap_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1160: {'origin': {'name': '_defaultmap_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEFAULT', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1161: {'origin': {'name': '_defaultmap_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FIRSTPRIVATE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1162: {'origin': {'name': '_defaultmap_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FROM', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1163: {'origin': {'name': '_defaultmap_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NONE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1164: {'origin': {'name': '_defaultmap_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PRESENT', 'filter_out': False, '__type__': 'Terminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1165: {'origin': {'name': '_defaultmap_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PRIVATE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1166: {'origin': {'name': '_defaultmap_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SELF', 'filter_out': False, '__type__': 'Terminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1167: {'origin': {'name': '_defaultmap_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'STORAGE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1168: {'origin': {'name': '_defaultmap_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TO', 'filter_out': False, '__type__': 'Terminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1169: {'origin': {'name': '_defaultmap_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TOFROM', 'filter_out': False, '__type__': 'Terminal'}], 'order': 9, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1170: {'origin': {'name': '_defaultmap_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1171: {'origin': {'name': '_defaultmap_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'variable_category_name', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1172: {'origin': {'name': '_defaultmap_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'variable_category_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1173: {'origin': {'name': '_defaultmap_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'variable_category_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1174: {'origin': {'name': 'uses_allocators_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'USES_ALLOCATORS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_uses_allocator_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1175: {'origin': {'name': 'uses_allocators_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'USES_ALLOCATORS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1176: {'origin': {'name': '_uses_allocator_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_uses_allocator_modifier', '__type__': 'NonTerminal'}, {'name': '___uses_allocator_modifier_list_star_21', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1177: {'origin': {'name': '_uses_allocator_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_uses_allocator_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1178: {'origin': {'name': '_uses_allocator_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'memspace_modifier', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1179: {'origin': {'name': '_uses_allocator_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'traits_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1180: {'origin': {'name': '_uses_allocator_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1181: {'origin': {'name': 'target_update_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET_UPDATE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_target_update_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1182: {'origin': {'name': 'target_update_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET_UPDATE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1183: {'origin': {'name': '_target_update_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_target_update_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_target_update_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1184: {'origin': {'name': '_target_update_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_target_update_clause', '__type__': 'NonTerminal'}, {'name': '_target_update_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1185: {'origin': {'name': '_target_update_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_target_update_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1186: {'origin': {'name': '_target_update_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'depend_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1187: {'origin': {'name': '_target_update_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'device_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1188: {'origin': {'name': '_target_update_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'from_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1189: {'origin': {'name': '_target_update_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'if_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1190: {'origin': {'name': '_target_update_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nowait_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1191: {'origin': {'name': '_target_update_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'priority_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1192: {'origin': {'name': '_target_update_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'replayable_clause', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1193: {'origin': {'name': '_target_update_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'to_clause', '__type__': 'NonTerminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1194: {'origin': {'name': 'to_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TO_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_to_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1195: {'origin': {'name': 'to_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TO_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1196: {'origin': {'name': '_to_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_from_modifier', '__type__': 'NonTerminal'}, {'name': '___to_modifier_list_star_22', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1197: {'origin': {'name': '_to_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_from_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1198: {'origin': {'name': 'present_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PRESENT', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1199: {'origin': {'name': 'from_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FROM_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_from_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1200: {'origin': {'name': 'from_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FROM_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1201: {'origin': {'name': '_from_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_from_modifier', '__type__': 'NonTerminal'}, {'name': '___to_modifier_list_star_22', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1202: {'origin': {'name': '_from_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_from_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1203: {'origin': {'name': '_from_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'present_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1204: {'origin': {'name': '_from_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'mapper_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1205: {'origin': {'name': '_from_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'iterator_modifier', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1206: {'origin': {'name': '_from_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1207: {'origin': {'name': 'interop_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INTEROP_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_interop_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1208: {'origin': {'name': '_interop_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_interop_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_interop_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1209: {'origin': {'name': '_interop_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_interop_clause', '__type__': 'NonTerminal'}, {'name': '_interop_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1210: {'origin': {'name': '_interop_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_interop_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1211: {'origin': {'name': '_interop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'depend_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1212: {'origin': {'name': '_interop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'destroy_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1213: {'origin': {'name': '_interop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'device_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1214: {'origin': {'name': '_interop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'init_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1215: {'origin': {'name': '_interop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nowait_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1216: {'origin': {'name': '_interop_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'use_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1217: {'origin': {'name': 'destroy_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DESTROY_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1218: {'origin': {'name': 'destroy_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DESTROY_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1219: {'origin': {'name': 'init_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INIT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_init_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1220: {'origin': {'name': 'init_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INIT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1221: {'origin': {'name': '_init_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_init_modifier', '__type__': 'NonTerminal'}, {'name': '___init_modifier_list_star_23', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1222: {'origin': {'name': '_init_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_init_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1223: {'origin': {'name': '_init_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'interop_type_modifier_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1224: {'origin': {'name': '_init_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'prefer_type_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1225: {'origin': {'name': '_init_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'depinfo_modifier', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1226: {'origin': {'name': '_init_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1227: {'origin': {'name': 'interop_type_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGET', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1228: {'origin': {'name': 'interop_type_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TARGETSYNC', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1229: {'origin': {'name': 'use_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'USE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1230: {'origin': {'name': 'use_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'USE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1231: {'origin': {'name': 'critical_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CRITICAL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'hint_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1232: {'origin': {'name': 'critical_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CRITICAL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'hint_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1233: {'origin': {'name': 'critical_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CRITICAL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, False, False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1234: {'origin': {'name': 'critical_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CRITICAL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1235: {'origin': {'name': 'hint_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'HINT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1236: {'origin': {'name': 'hint_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'HINT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1237: {'origin': {'name': 'barrier_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'BARRIER_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1238: {'origin': {'name': 'taskgroup_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASKGROUP_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_taskgroup_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1239: {'origin': {'name': 'taskgroup_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASKGROUP_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1240: {'origin': {'name': '_taskgroup_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_taskgroup_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_taskgroup_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1241: {'origin': {'name': '_taskgroup_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_taskgroup_clause', '__type__': 'NonTerminal'}, {'name': '_taskgroup_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1242: {'origin': {'name': '_taskgroup_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_taskgroup_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1243: {'origin': {'name': '_taskgroup_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'allocate_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1244: {'origin': {'name': '_taskgroup_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'task_reduction_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1245: {'origin': {'name': 'task_reduction_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASK_REDUCTION_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'reduction_op', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1246: {'origin': {'name': 'task_reduction_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASK_REDUCTION_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'reduction_op', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1247: {'origin': {'name': 'taskwait_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASKWAIT_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_taskwait_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1248: {'origin': {'name': 'taskwait_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASKWAIT_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1249: {'origin': {'name': '_taskwait_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_taskwait_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_taskwait_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1250: {'origin': {'name': '_taskwait_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_taskwait_clause', '__type__': 'NonTerminal'}, {'name': '_taskwait_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1251: {'origin': {'name': '_taskwait_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_taskwait_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1252: {'origin': {'name': '_taskwait_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'depend_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1253: {'origin': {'name': '_taskwait_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'nowait_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1254: {'origin': {'name': '_taskwait_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'replayable_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1255: {'origin': {'name': 'atomic_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ATOMIC_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_atomic_clause_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1256: {'origin': {'name': '_atomic_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_atomic_clause', '__type__': 'NonTerminal'}, {'name': '___atomic_clause_list_star_24', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1257: {'origin': {'name': '_atomic_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_atomic_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1258: {'origin': {'name': '_atomic_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'read_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1259: {'origin': {'name': '_atomic_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'atomic_update_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1260: {'origin': {'name': '_atomic_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'write_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1261: {'origin': {'name': '_atomic_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'capture_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1262: {'origin': {'name': '_atomic_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'compare_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1263: {'origin': {'name': '_atomic_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'fail_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1264: {'origin': {'name': '_atomic_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'weak_clause', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1265: {'origin': {'name': '_atomic_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'acq_rel_clause', '__type__': 'NonTerminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1266: {'origin': {'name': '_atomic_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'acquire_clause', '__type__': 'NonTerminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1267: {'origin': {'name': '_atomic_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'relaxed_clause', '__type__': 'NonTerminal'}], 'order': 9, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1268: {'origin': {'name': '_atomic_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'release_clause', '__type__': 'NonTerminal'}], 'order': 10, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1269: {'origin': {'name': '_atomic_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'seq_cst_clause', '__type__': 'NonTerminal'}], 'order': 11, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1270: {'origin': {'name': '_atomic_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'memscope_clause', '__type__': 'NonTerminal'}], 'order': 12, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1271: {'origin': {'name': '_atomic_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'hint_clause', '__type__': 'NonTerminal'}], 'order': 13, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1272: {'origin': {'name': 'memscope_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MEMSCOPE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'memscope_clause_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1273: {'origin': {'name': 'memscope_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MEMSCOPE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'memscope_clause_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1274: {'origin': {'name': 'memscope_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ALL', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1275: {'origin': {'name': 'memscope_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CGROUP', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1276: {'origin': {'name': 'memscope_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEVICE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1277: {'origin': {'name': 'read_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'READ_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1278: {'origin': {'name': 'read_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'READ_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1279: {'origin': {'name': 'read_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'READ_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1280: {'origin': {'name': 'atomic_update_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UPDATE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1281: {'origin': {'name': 'atomic_update_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UPDATE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1282: {'origin': {'name': 'atomic_update_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UPDATE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1283: {'origin': {'name': 'write_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'WRITE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1284: {'origin': {'name': 'write_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'WRITE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1285: {'origin': {'name': 'write_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'WRITE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1286: {'origin': {'name': 'capture_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CAPTURE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1287: {'origin': {'name': 'capture_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CAPTURE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1288: {'origin': {'name': 'capture_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CAPTURE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1289: {'origin': {'name': 'compare_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMPARE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1290: {'origin': {'name': 'compare_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMPARE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1291: {'origin': {'name': 'compare_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMPARE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1292: {'origin': {'name': 'fail_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FAIL_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'fail_clause_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1293: {'origin': {'name': 'fail_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FAIL_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'fail_clause_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1294: {'origin': {'name': 'fail_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ACQUIRE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1295: {'origin': {'name': 'fail_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'RELAXED', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1296: {'origin': {'name': 'fail_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SEQ_CST', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1297: {'origin': {'name': 'weak_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'WEAK_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1298: {'origin': {'name': 'weak_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'WEAK_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1299: {'origin': {'name': 'weak_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'WEAK_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1300: {'origin': {'name': 'acq_rel_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ACQ_REL_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1301: {'origin': {'name': 'acq_rel_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ACQ_REL_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1302: {'origin': {'name': 'acq_rel_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ACQ_REL_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1303: {'origin': {'name': 'acquire_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ACQUIRE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1304: {'origin': {'name': 'acquire_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ACQUIRE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1305: {'origin': {'name': 'acquire_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ACQUIRE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1306: {'origin': {'name': 'relaxed_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'RELAXED_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1307: {'origin': {'name': 'relaxed_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'RELAXED_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1308: {'origin': {'name': 'relaxed_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'RELAXED_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1309: {'origin': {'name': 'release_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'RELEASE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1310: {'origin': {'name': 'release_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'RELEASE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1311: {'origin': {'name': 'release_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'RELEASE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1312: {'origin': {'name': 'seq_cst_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SEQ_CST_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1313: {'origin': {'name': 'seq_cst_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SEQ_CST_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1314: {'origin': {'name': 'seq_cst_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SEQ_CST_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1315: {'origin': {'name': 'flush_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FLUSH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'acq_rel_clause', '__type__': 'NonTerminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1316: {'origin': {'name': 'flush_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FLUSH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'acq_rel_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1317: {'origin': {'name': 'flush_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FLUSH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'acquire_clause', '__type__': 'NonTerminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1318: {'origin': {'name': 'flush_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FLUSH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'acquire_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1319: {'origin': {'name': 'flush_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FLUSH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'relaxed_clause', '__type__': 'NonTerminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1320: {'origin': {'name': 'flush_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FLUSH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'relaxed_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1321: {'origin': {'name': 'flush_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FLUSH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'release_clause', '__type__': 'NonTerminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1322: {'origin': {'name': 'flush_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FLUSH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'release_clause', '__type__': 'NonTerminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1323: {'origin': {'name': 'flush_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FLUSH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'seq_cst_clause', '__type__': 'NonTerminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1324: {'origin': {'name': 'flush_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FLUSH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'seq_cst_clause', '__type__': 'NonTerminal'}], 'order': 9, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1325: {'origin': {'name': 'flush_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FLUSH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'memscope_clause', '__type__': 'NonTerminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 10, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1326: {'origin': {'name': 'flush_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FLUSH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'memscope_clause', '__type__': 'NonTerminal'}], 'order': 11, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1327: {'origin': {'name': 'flush_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FLUSH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 12, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, False, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1328: {'origin': {'name': 'flush_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FLUSH_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 13, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1329: {'origin': {'name': 'depobj_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEPOBJ_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'destroy_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1330: {'origin': {'name': 'depobj_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEPOBJ_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'init_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1331: {'origin': {'name': 'depobj_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEPOBJ_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'depobj_update_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1332: {'origin': {'name': 'depobj_update_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UPDATE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_depobj_update_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1333: {'origin': {'name': 'depobj_update_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UPDATE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1334: {'origin': {'name': '_depobj_update_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1335: {'origin': {'name': '_depobj_update_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'task_dependence_name', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1336: {'origin': {'name': '_depobj_update_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'task_dependence_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1337: {'origin': {'name': '_depobj_update_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'task_dependence_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1338: {'origin': {'name': 'ordered_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ORDERED_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'doacross_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1339: {'origin': {'name': 'ordered_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ORDERED_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_ordered_clause_list', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1340: {'origin': {'name': 'ordered_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ORDERED_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1341: {'origin': {'name': '_ordered_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'threads_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1342: {'origin': {'name': '_ordered_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'simd_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1343: {'origin': {'name': '_ordered_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'threads_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'simd_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1344: {'origin': {'name': '_ordered_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'threads_clause', '__type__': 'NonTerminal'}, {'name': 'simd_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1345: {'origin': {'name': '_ordered_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'simd_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'threads_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1346: {'origin': {'name': '_ordered_clause_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'simd_clause', '__type__': 'NonTerminal'}, {'name': 'threads_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1347: {'origin': {'name': 'doacross_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DOACROSS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_doacross_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'iterator_specifier', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1348: {'origin': {'name': '_doacross_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'dependence_type_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1349: {'origin': {'name': '_doacross_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'dependence_type_name', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1350: {'origin': {'name': '_doacross_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'dependence_type_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1351: {'origin': {'name': 'dependence_type_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SINK', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1352: {'origin': {'name': 'dependence_type_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SOURCE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1353: {'origin': {'name': 'threads_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'THREADS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1354: {'origin': {'name': 'threads_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'THREADS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1355: {'origin': {'name': 'threads_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'THREADS_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1356: {'origin': {'name': 'simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SIMD_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1357: {'origin': {'name': 'simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SIMD_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1358: {'origin': {'name': 'simd_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SIMD_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1359: {'origin': {'name': 'cancel_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CANCEL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_construct_type_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'if_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1360: {'origin': {'name': 'cancel_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CANCEL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_construct_type_clause', '__type__': 'NonTerminal'}, {'name': 'if_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1361: {'origin': {'name': 'cancel_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CANCEL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_construct_type_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, False, False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1362: {'origin': {'name': 'cancel_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CANCEL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_construct_type_clause', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'if_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, False, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1363: {'origin': {'name': 'cancel_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CANCEL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_construct_type_clause', '__type__': 'NonTerminal'}, {'name': 'if_clause', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1364: {'origin': {'name': 'cancel_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CANCEL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_construct_type_clause', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1365: {'origin': {'name': '_construct_type_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PARALLEL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1366: {'origin': {'name': '_construct_type_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SECTIONS_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1367: {'origin': {'name': '_construct_type_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASKGROUP_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1368: {'origin': {'name': '_construct_type_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FOR_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1369: {'origin': {'name': 'cancellation_point_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CANCELLATION_POINT_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_construct_type_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1370: {'origin': {'name': 'cancellation_point_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CANCELLATION_POINT_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '_construct_type_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1371: {'origin': {'name': 'apply_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'APPLY_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_apply_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'apply_clause_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1372: {'origin': {'name': 'apply_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'APPLY_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'apply_clause_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1373: {'origin': {'name': '_apply_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'loop_modifier', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1374: {'origin': {'name': 'apply_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_apply_directive', '__type__': 'NonTerminal'}, {'name': '__apply_clause_arg_star_25', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1375: {'origin': {'name': 'apply_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_apply_directive', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1376: {'origin': {'name': '_apply_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FUSE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1377: {'origin': {'name': '_apply_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INTERCHANGE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1378: {'origin': {'name': '_apply_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NOTHING_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1379: {'origin': {'name': '_apply_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'REVERSE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1380: {'origin': {'name': '_apply_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SPLIT_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1381: {'origin': {'name': '_apply_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'STRIPE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1382: {'origin': {'name': '_apply_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TILE_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1383: {'origin': {'name': '_apply_directive', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UNROLL_DIRECTIVE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1384: {'origin': {'name': 'depend_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEPEND_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_depend_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'expr_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1385: {'origin': {'name': 'depend_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEPEND_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'expr_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1386: {'origin': {'name': '_depend_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_depend_modifier', '__type__': 'NonTerminal'}, {'name': '___depend_modifier_list_star_26', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1387: {'origin': {'name': '_depend_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_depend_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1388: {'origin': {'name': '_depend_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'task_dependence_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1389: {'origin': {'name': '_depend_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'iterator_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1390: {'origin': {'name': '_depend_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1391: {'origin': {'name': 'task_dependence_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEPOBJ', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1392: {'origin': {'name': 'task_dependence_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'IN', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1393: {'origin': {'name': 'task_dependence_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INOUT', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1394: {'origin': {'name': 'task_dependence_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INOUTSET', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1395: {'origin': {'name': 'task_dependence_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MUTEXINOUTSET', 'filter_out': False, '__type__': 'Terminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1396: {'origin': {'name': 'task_dependence_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'OUT', 'filter_out': False, '__type__': 'Terminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1397: {'origin': {'name': 'device_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEVICE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_device_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1398: {'origin': {'name': 'device_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEVICE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1399: {'origin': {'name': '_device_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'device_modifier_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1400: {'origin': {'name': '_device_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1401: {'origin': {'name': '_device_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'device_modifier_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1402: {'origin': {'name': '_device_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'device_modifier_name', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1403: {'origin': {'name': 'device_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ANCESTOR', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1404: {'origin': {'name': 'device_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEVICE_NUM', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1405: {'origin': {'name': 'default_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEFAULT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'NONE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_default_modifier', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1406: {'origin': {'name': 'default_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEFAULT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'NONE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1407: {'origin': {'name': 'default_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEFAULT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'SHARED', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_default_modifier', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1408: {'origin': {'name': 'default_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEFAULT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'SHARED', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1409: {'origin': {'name': 'default_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEFAULT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'FIRSTPRIVATE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_default_modifier', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1410: {'origin': {'name': 'default_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEFAULT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'FIRSTPRIVATE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1411: {'origin': {'name': 'default_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEFAULT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'PRIVATE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_default_modifier', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1412: {'origin': {'name': 'default_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEFAULT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'PRIVATE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1413: {'origin': {'name': '_default_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1414: {'origin': {'name': '_default_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'variable_category_name', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1415: {'origin': {'name': '_default_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'variable_category_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1416: {'origin': {'name': '_default_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'variable_category_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1417: {'origin': {'name': 'variable_category_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ALL', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1418: {'origin': {'name': 'variable_category_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ALLOCATABLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1419: {'origin': {'name': 'variable_category_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'POINTER', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1420: {'origin': {'name': 'variable_category_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SCALAR', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1421: {'origin': {'name': 'variable_category_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'AGGREGATE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1422: {'origin': {'name': 'private_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PRIVATE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1423: {'origin': {'name': 'private_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PRIVATE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1424: {'origin': {'name': 'if_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'IF_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1425: {'origin': {'name': 'if_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'IF_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1426: {'origin': {'name': 'firstprivate_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FIRSTPRIVATE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_firstprivate_modifier', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1427: {'origin': {'name': 'firstprivate_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FIRSTPRIVATE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1428: {'origin': {'name': '_firstprivate_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1429: {'origin': {'name': '_firstprivate_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'saved_name', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1430: {'origin': {'name': '_firstprivate_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'saved_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1431: {'origin': {'name': '_firstprivate_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'saved_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1432: {'origin': {'name': 'saved_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SAVED', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1433: {'origin': {'name': 'reduction_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'REDUCTION_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_reduction_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'reduction_op', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1434: {'origin': {'name': 'reduction_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'REDUCTION_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'reduction_op', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1435: {'origin': {'name': '_reduction_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_reduction_modifier', '__type__': 'NonTerminal'}, {'name': '___reduction_modifier_list_star_27', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1436: {'origin': {'name': '_reduction_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_reduction_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1437: {'origin': {'name': '_reduction_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'reduction_modifier_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1438: {'origin': {'name': '_reduction_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'original_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1439: {'origin': {'name': '_reduction_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1440: {'origin': {'name': 'reduction_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INSCAN', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1441: {'origin': {'name': 'reduction_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TASK', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1442: {'origin': {'name': 'reduction_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DEFAULT', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1443: {'origin': {'name': 'induction_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INDUCTION_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_induction_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'induction_op', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1444: {'origin': {'name': '_induction_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'step_modifier', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1445: {'origin': {'name': '_induction_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'step_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1446: {'origin': {'name': '_induction_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'step_modifier', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1447: {'origin': {'name': '_induction_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'induction_modifier_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'step_modifier', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1448: {'origin': {'name': '_induction_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'step_modifier', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'induction_modifier_name', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1449: {'origin': {'name': '_induction_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'step_modifier', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'induction_modifier_name', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1450: {'origin': {'name': '_induction_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'induction_modifier_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'step_modifier', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1451: {'origin': {'name': '_induction_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'induction_modifier_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'step_modifier', '__type__': 'NonTerminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1452: {'origin': {'name': '_induction_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'induction_modifier_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'step_modifier', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1453: {'origin': {'name': '_induction_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'step_modifier', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'induction_modifier_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 9, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1454: {'origin': {'name': '_induction_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'step_modifier', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'induction_modifier_name', '__type__': 'NonTerminal'}], 'order': 10, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1455: {'origin': {'name': 'induction_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'RELAXED', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1456: {'origin': {'name': 'induction_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'STRICT', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1457: {'origin': {'name': 'shared_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SHARED_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1458: {'origin': {'name': 'shared_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SHARED_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1459: {'origin': {'name': 'collapse_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COLLAPSE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1460: {'origin': {'name': 'collapse_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COLLAPSE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1461: {'origin': {'name': 'lastprivate_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LASTPRIVATE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_lastprivate_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1462: {'origin': {'name': 'lastprivate_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LASTPRIVATE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1463: {'origin': {'name': '_lastprivate_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'conditional_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1464: {'origin': {'name': '_lastprivate_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1465: {'origin': {'name': '_lastprivate_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'conditional_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1466: {'origin': {'name': '_lastprivate_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'conditional_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1467: {'origin': {'name': 'conditional_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CONDITIONAL', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1468: {'origin': {'name': 'allocate_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ALLOCATE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_allocate_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1469: {'origin': {'name': 'allocate_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ALLOCATE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1470: {'origin': {'name': '_allocate_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_allocate_modifier', '__type__': 'NonTerminal'}, {'name': '___allocate_modifier_list_star_28', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1471: {'origin': {'name': '_allocate_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_allocate_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1472: {'origin': {'name': '_allocate_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'allocator_simple_modifier', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1473: {'origin': {'name': '_allocate_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'allocator_modifier', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1474: {'origin': {'name': '_allocate_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'align_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1475: {'origin': {'name': '_allocate_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1476: {'origin': {'name': 'allocator_simple_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'py_expr', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1477: {'origin': {'name': 'nowait_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NOWAIT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1478: {'origin': {'name': 'nowait_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NOWAIT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1479: {'origin': {'name': 'nowait_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NOWAIT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1480: {'origin': {'name': 'final_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FINAL_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1481: {'origin': {'name': 'final_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FINAL_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1482: {'origin': {'name': 'mergeable_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MERGEABLE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1483: {'origin': {'name': 'mergeable_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MERGEABLE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1484: {'origin': {'name': 'mergeable_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MERGEABLE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1485: {'origin': {'name': 'untied_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UNTIED_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1486: {'origin': {'name': 'untied_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UNTIED_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1487: {'origin': {'name': 'untied_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UNTIED_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1488: {'origin': {'name': 'affinity_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'AFFINITY_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_affinity_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1489: {'origin': {'name': 'affinity_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'AFFINITY_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1490: {'origin': {'name': '_affinity_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'iterator_modifier', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1491: {'origin': {'name': '_affinity_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1492: {'origin': {'name': '_affinity_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'iterator_modifier', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1493: {'origin': {'name': '_affinity_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'iterator_modifier', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1494: {'origin': {'name': 'detach_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DETACH_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1495: {'origin': {'name': 'detach_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DETACH_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1496: {'origin': {'name': 'in_reduction_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'IN_REDUCTION_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'reduction_op', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1497: {'origin': {'name': 'in_reduction_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'IN_REDUCTION_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'reduction_op', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1498: {'origin': {'name': 'priority_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PRIORITY_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1499: {'origin': {'name': 'priority_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PRIORITY_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1500: {'origin': {'name': 'replayable_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'REPLAYABLE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1501: {'origin': {'name': 'replayable_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'REPLAYABLE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1502: {'origin': {'name': 'replayable_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'REPLAYABLE_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1503: {'origin': {'name': 'threadset_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'THREADSET_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'threadset_clause_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1504: {'origin': {'name': 'threadset_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'THREADSET_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'threadset_clause_arg', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1505: {'origin': {'name': 'threadset_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'OMP_TEAM', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1506: {'origin': {'name': 'threadset_clause_arg', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'OMP_POOL', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': 'name', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1507: {'origin': {'name': 'transparent_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TRANSPARENT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1508: {'origin': {'name': 'transparent_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TRANSPARENT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1509: {'origin': {'name': 'transparent_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TRANSPARENT_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1510: {'origin': {'name': 'nogroup_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NOGROUP_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1511: {'origin': {'name': 'nogroup_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NOGROUP_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1512: {'origin': {'name': 'nogroup_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NOGROUP_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1513: {'origin': {'name': 'map_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MAP_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_map_modifier_list', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'map_type_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1514: {'origin': {'name': 'map_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MAP_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'map_type_name', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1515: {'origin': {'name': 'map_clause', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MAP_CLAUSE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, True, False, False), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1516: {'origin': {'name': '_map_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_map_modifier', '__type__': 'NonTerminal'}, {'name': '___map_modifier_list_star_29', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1517: {'origin': {'name': '_map_modifier_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_map_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1518: {'origin': {'name': '_map_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'always_modifier_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1519: {'origin': {'name': '_map_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'close_modifier_name', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1520: {'origin': {'name': '_map_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'present_modifier_name', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1521: {'origin': {'name': '_map_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'self_modifier_name', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1522: {'origin': {'name': '_map_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'delete_modifier_name', '__type__': 'NonTerminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1523: {'origin': {'name': '_map_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ref_modifier_name', '__type__': 'NonTerminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1524: {'origin': {'name': '_map_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'mapper_modifier', '__type__': 'NonTerminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1525: {'origin': {'name': '_map_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'iterator_modifier', '__type__': 'NonTerminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1526: {'origin': {'name': '_map_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1527: {'origin': {'name': 'map_type_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FROM', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1528: {'origin': {'name': 'map_type_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'STORAGE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1529: {'origin': {'name': 'map_type_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TO', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1530: {'origin': {'name': 'map_type_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TOFROM', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1531: {'origin': {'name': 'ref_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'REF_PTEE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1532: {'origin': {'name': 'ref_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'REF_PTR', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1533: {'origin': {'name': 'ref_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'REF_PTR_PTEE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1534: {'origin': {'name': 'always_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ALWAYS', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1535: {'origin': {'name': 'close_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'CLOSE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1536: {'origin': {'name': 'present_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PRESENT', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1537: {'origin': {'name': 'self_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SELF', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1538: {'origin': {'name': 'delete_modifier_name', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DELETE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1539: {'origin': {'name': 'py_code_out', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1540: {'origin': {'name': 'py_code_in', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1541: {'origin': {'name': 'py_expr', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'py_code_out', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1542: {'origin': {'name': 'py_type', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'py_code_out', '__type__': 'NonTerminal'}], 'order': 0, 'alias': 'py_expr', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1543: {'origin': {'name': 'py_stmt', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'py_code_out', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1544: {'origin': {'name': 'var_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': '__var_list_star_32', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1545: {'origin': {'name': 'var_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1546: {'origin': {'name': 'expr_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': '__expr_list_star_33', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1547: {'origin': {'name': 'expr_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'py_expr', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1548: {'origin': {'name': 'type_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'py_type', '__type__': 'NonTerminal'}, {'name': '__type_list_star_34', '__type__': 'NonTerminal'}], 'order': 0, 'alias': 'expr_list', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1549: {'origin': {'name': 'type_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'py_type', '__type__': 'NonTerminal'}], 'order': 1, 'alias': 'expr_list', 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1550: {'origin': {'name': 'stmt_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'py_stmt', '__type__': 'NonTerminal'}, {'name': '__stmt_list_star_35', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1551: {'origin': {'name': 'stmt_list', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'py_stmt', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1552: {'origin': {'name': 'reduction_op', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1553: {'origin': {'name': 'reduction_op', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PLUS', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1554: {'origin': {'name': 'reduction_op', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MULT', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1555: {'origin': {'name': 'reduction_op', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'BITWISE_AND', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1556: {'origin': {'name': 'reduction_op', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'BITWISE_OR', 'filter_out': False, '__type__': 'Terminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1557: {'origin': {'name': 'reduction_op', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'BITWISE_XOR', 'filter_out': False, '__type__': 'Terminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1558: {'origin': {'name': 'reduction_op', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LOGIC_AND', 'filter_out': False, '__type__': 'Terminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1559: {'origin': {'name': 'reduction_op', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LOGIC_OR', 'filter_out': False, '__type__': 'Terminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1560: {'origin': {'name': 'reduction_op', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MAX', 'filter_out': False, '__type__': 'Terminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1561: {'origin': {'name': 'reduction_op', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MIN', 'filter_out': False, '__type__': 'Terminal'}], 'order': 9, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1562: {'origin': {'name': 'induction_op', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1563: {'origin': {'name': 'induction_op', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PLUS', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1564: {'origin': {'name': 'induction_op', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MULT', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1565: {'origin': {'name': 'original_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ORIGINAL', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'DEFAULT', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1566: {'origin': {'name': 'original_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ORIGINAL', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'PRIVATE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1567: {'origin': {'name': 'original_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ORIGINAL', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'SHARED', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1568: {'origin': {'name': 'iterator_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ITERATOR', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'iterator_specifier', '__type__': 'NonTerminal'}, {'name': '__iterator_modifier_star_36', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1569: {'origin': {'name': 'iterator_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ITERATOR', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'iterator_specifier', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1570: {'origin': {'name': 'iterator_specifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'EQUAL', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1571: {'origin': {'name': 'iterator_specifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'EQUAL', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'COLON', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, False, False, False, False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1572: {'origin': {'name': 'step_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'STEP', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1573: {'origin': {'name': 'allocator_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ALLOCATOR', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1574: {'origin': {'name': 'align_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ALIGN', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1575: {'origin': {'name': 'mapper_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MAPPER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1576: {'origin': {'name': 'memspace_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MEMSPACE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1577: {'origin': {'name': 'traits_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TRAITS', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1578: {'origin': {'name': 'depinfo_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'IN', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1579: {'origin': {'name': 'depinfo_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INOUT', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1580: {'origin': {'name': 'depinfo_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INOUTSET', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1581: {'origin': {'name': 'depinfo_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'MUTEXINOUTSET', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1582: {'origin': {'name': 'depinfo_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'OUT', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'var_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1583: {'origin': {'name': 'loop_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FUSED', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'expr_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1584: {'origin': {'name': 'loop_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FUSED', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1585: {'origin': {'name': 'loop_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'GRID', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'expr_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1586: {'origin': {'name': 'loop_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'GRID', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1587: {'origin': {'name': 'loop_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'IDENTITY', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'expr_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1588: {'origin': {'name': 'loop_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'IDENTITY', 'filter_out': False, '__type__': 'Terminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1589: {'origin': {'name': 'loop_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INTERCHANGED', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'expr_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1590: {'origin': {'name': 'loop_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INTERCHANGED', 'filter_out': False, '__type__': 'Terminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1591: {'origin': {'name': 'loop_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INTRATILE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'expr_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1592: {'origin': {'name': 'loop_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'INTRATILE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 9, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1593: {'origin': {'name': 'loop_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'OFFSETS', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'expr_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 10, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1594: {'origin': {'name': 'loop_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'OFFSETS', 'filter_out': False, '__type__': 'Terminal'}], 'order': 11, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1595: {'origin': {'name': 'loop_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'REVERSED', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'expr_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 12, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1596: {'origin': {'name': 'loop_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'REVERSED', 'filter_out': False, '__type__': 'Terminal'}], 'order': 13, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1597: {'origin': {'name': 'loop_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SPLIT', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'expr_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 14, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1598: {'origin': {'name': 'loop_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SPLIT', 'filter_out': False, '__type__': 'Terminal'}], 'order': 15, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1599: {'origin': {'name': 'loop_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UNROLLED', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'expr_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 16, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1600: {'origin': {'name': 'loop_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UNROLLED', 'filter_out': False, '__type__': 'Terminal'}], 'order': 17, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (False, True), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1601: {'origin': {'name': 'prefer_type_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PREFER_TYPE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'preference_specification', '__type__': 'NonTerminal'}, {'name': '__prefer_type_modifier_star_37', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1602: {'origin': {'name': 'prefer_type_modifier', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PREFER_TYPE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'preference_specification', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1603: {'origin': {'name': 'preference_specification', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LBRACE', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'fr_selector', '__type__': 'NonTerminal'}, {'name': '__preference_specification_star_38', '__type__': 'NonTerminal'}, {'name': 'RBRACE', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1604: {'origin': {'name': 'preference_specification', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LBRACE', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'fr_selector', '__type__': 'NonTerminal'}, {'name': 'RBRACE', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1605: {'origin': {'name': 'preference_specification', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LBRACE', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'attr_selector', '__type__': 'NonTerminal'}, {'name': '__preference_specification_star_38', '__type__': 'NonTerminal'}, {'name': 'RBRACE', 'filter_out': True, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1606: {'origin': {'name': 'preference_specification', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LBRACE', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'attr_selector', '__type__': 'NonTerminal'}, {'name': 'RBRACE', 'filter_out': True, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1607: {'origin': {'name': 'preference_specification', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1608: {'origin': {'name': 'fr_selector', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'FR', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1609: {'origin': {'name': 'attr_selector', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ATTR', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'expr_list', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1610: {'origin': {'name': 'context_selector', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'stmt_list', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1611: {'origin': {'name': '__combined_directive_plus_0', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_combined_directive_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1612: {'origin': {'name': '__combined_directive_plus_0', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__combined_directive_plus_0', '__type__': 'NonTerminal'}, {'name': '_combined_directive_name', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1613: {'origin': {'name': '__combined_clause_list_star_1', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_combined_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1614: {'origin': {'name': '__combined_clause_list_star_1', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_combined_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1615: {'origin': {'name': '__combined_clause_list_star_1', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__combined_clause_list_star_1', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_combined_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1616: {'origin': {'name': '__combined_clause_list_star_1', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__combined_clause_list_star_1', '__type__': 'NonTerminal'}, {'name': '_combined_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1617: {'origin': {'name': '__declare_mapper_directive_plus_2', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'map_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1618: {'origin': {'name': '__declare_mapper_directive_plus_2', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__declare_mapper_directive_plus_2', '__type__': 'NonTerminal'}, {'name': 'map_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1619: {'origin': {'name': '___allocate_clause_list_star_3', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_allocate_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1620: {'origin': {'name': '___allocate_clause_list_star_3', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_allocate_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1621: {'origin': {'name': '___allocate_clause_list_star_3', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___allocate_clause_list_star_3', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_allocate_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1622: {'origin': {'name': '___allocate_clause_list_star_3', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___allocate_clause_list_star_3', '__type__': 'NonTerminal'}, {'name': '_allocate_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1623: {'origin': {'name': '___metadirective_clause_list_star_4', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'when_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1624: {'origin': {'name': '___metadirective_clause_list_star_4', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'when_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1625: {'origin': {'name': '___metadirective_clause_list_star_4', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___metadirective_clause_list_star_4', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'when_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1626: {'origin': {'name': '___metadirective_clause_list_star_4', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___metadirective_clause_list_star_4', '__type__': 'NonTerminal'}, {'name': 'when_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1627: {'origin': {'name': '___declare_variant_clause_list_star_5', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_declare_variant_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1628: {'origin': {'name': '___declare_variant_clause_list_star_5', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_declare_variant_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1629: {'origin': {'name': '___declare_variant_clause_list_star_5', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___declare_variant_clause_list_star_5', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_declare_variant_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1630: {'origin': {'name': '___declare_variant_clause_list_star_5', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___declare_variant_clause_list_star_5', '__type__': 'NonTerminal'}, {'name': '_declare_variant_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1631: {'origin': {'name': '__append_args_arg_star_6', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'append_op', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1632: {'origin': {'name': '__append_args_arg_star_6', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__append_args_arg_star_6', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'append_op', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1633: {'origin': {'name': '__append_op_star_7', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'interop_type', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1634: {'origin': {'name': '__append_op_star_7', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__append_op_star_7', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'interop_type', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1635: {'origin': {'name': '___dispatch_clause_list_star_8', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_dispatch_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1636: {'origin': {'name': '___dispatch_clause_list_star_8', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_dispatch_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1637: {'origin': {'name': '___dispatch_clause_list_star_8', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___dispatch_clause_list_star_8', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_dispatch_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1638: {'origin': {'name': '___dispatch_clause_list_star_8', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___dispatch_clause_list_star_8', '__type__': 'NonTerminal'}, {'name': '_dispatch_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1639: {'origin': {'name': '___declare_simd_clause_list_star_9', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_declare_simd_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1640: {'origin': {'name': '___declare_simd_clause_list_star_9', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_declare_simd_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1641: {'origin': {'name': '___declare_simd_clause_list_star_9', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___declare_simd_clause_list_star_9', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_declare_simd_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1642: {'origin': {'name': '___declare_simd_clause_list_star_9', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___declare_simd_clause_list_star_9', '__type__': 'NonTerminal'}, {'name': '_declare_simd_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1643: {'origin': {'name': '___linear_modifier_list_star_10', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_linear_modifier', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1644: {'origin': {'name': '___linear_modifier_list_star_10', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___linear_modifier_list_star_10', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_linear_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1645: {'origin': {'name': '___declare_target_clause_list_star_11', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_declare_target_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1646: {'origin': {'name': '___declare_target_clause_list_star_11', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_declare_target_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1647: {'origin': {'name': '___declare_target_clause_list_star_11', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___declare_target_clause_list_star_11', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_declare_target_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1648: {'origin': {'name': '___declare_target_clause_list_star_11', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___declare_target_clause_list_star_11', '__type__': 'NonTerminal'}, {'name': '_declare_target_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1649: {'origin': {'name': '___requires_directive_clause_list_star_12', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_requires_directive_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1650: {'origin': {'name': '___requires_directive_clause_list_star_12', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_requires_directive_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1651: {'origin': {'name': '___requires_directive_clause_list_star_12', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___requires_directive_clause_list_star_12', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_requires_directive_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1652: {'origin': {'name': '___requires_directive_clause_list_star_12', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___requires_directive_clause_list_star_12', '__type__': 'NonTerminal'}, {'name': '_requires_directive_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1653: {'origin': {'name': '___assume_clause_list_star_13', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_assume_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1654: {'origin': {'name': '___assume_clause_list_star_13', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_assume_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1655: {'origin': {'name': '___assume_clause_list_star_13', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___assume_clause_list_star_13', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_assume_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1656: {'origin': {'name': '___assume_clause_list_star_13', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___assume_clause_list_star_13', '__type__': 'NonTerminal'}, {'name': '_assume_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1657: {'origin': {'name': '__directive_list_star_14', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1658: {'origin': {'name': '__directive_list_star_14', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__directive_list_star_14', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'directive_name', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1659: {'origin': {'name': '___parallel_clause_list_star_15', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_parallel_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1660: {'origin': {'name': '___parallel_clause_list_star_15', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_parallel_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1661: {'origin': {'name': '___parallel_clause_list_star_15', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___parallel_clause_list_star_15', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_parallel_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1662: {'origin': {'name': '___parallel_clause_list_star_15', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___parallel_clause_list_star_15', '__type__': 'NonTerminal'}, {'name': '_parallel_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1663: {'origin': {'name': '___single_clause_list_star_16', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_single_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1664: {'origin': {'name': '___single_clause_list_star_16', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_single_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1665: {'origin': {'name': '___single_clause_list_star_16', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___single_clause_list_star_16', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_single_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1666: {'origin': {'name': '___single_clause_list_star_16', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___single_clause_list_star_16', '__type__': 'NonTerminal'}, {'name': '_single_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1667: {'origin': {'name': '___sections_clause_list_star_17', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_sections_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1668: {'origin': {'name': '___sections_clause_list_star_17', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_sections_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1669: {'origin': {'name': '___sections_clause_list_star_17', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___sections_clause_list_star_17', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_sections_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1670: {'origin': {'name': '___sections_clause_list_star_17', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___sections_clause_list_star_17', '__type__': 'NonTerminal'}, {'name': '_sections_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1671: {'origin': {'name': '___for_clause_list_star_18', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_for_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1672: {'origin': {'name': '___for_clause_list_star_18', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_for_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1673: {'origin': {'name': '___for_clause_list_star_18', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___for_clause_list_star_18', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_for_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1674: {'origin': {'name': '___for_clause_list_star_18', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___for_clause_list_star_18', '__type__': 'NonTerminal'}, {'name': '_for_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1675: {'origin': {'name': '___schedule_modifier_list_star_19', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_schedule_modifier', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1676: {'origin': {'name': '___schedule_modifier_list_star_19', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___schedule_modifier_list_star_19', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_schedule_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1677: {'origin': {'name': '___task_clause_list_star_20', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_task_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1678: {'origin': {'name': '___task_clause_list_star_20', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_task_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1679: {'origin': {'name': '___task_clause_list_star_20', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___task_clause_list_star_20', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_task_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1680: {'origin': {'name': '___task_clause_list_star_20', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___task_clause_list_star_20', '__type__': 'NonTerminal'}, {'name': '_task_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1681: {'origin': {'name': '___uses_allocator_modifier_list_star_21', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_uses_allocator_modifier', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1682: {'origin': {'name': '___uses_allocator_modifier_list_star_21', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___uses_allocator_modifier_list_star_21', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_uses_allocator_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1683: {'origin': {'name': '___to_modifier_list_star_22', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_from_modifier', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1684: {'origin': {'name': '___to_modifier_list_star_22', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___to_modifier_list_star_22', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_from_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1685: {'origin': {'name': '___init_modifier_list_star_23', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_init_modifier', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1686: {'origin': {'name': '___init_modifier_list_star_23', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___init_modifier_list_star_23', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_init_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1687: {'origin': {'name': '___atomic_clause_list_star_24', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_atomic_clause', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1688: {'origin': {'name': '___atomic_clause_list_star_24', '__type__': 'NonTerminal'}, 'expansion': [{'name': '_atomic_clause', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1689: {'origin': {'name': '___atomic_clause_list_star_24', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___atomic_clause_list_star_24', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_atomic_clause', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1690: {'origin': {'name': '___atomic_clause_list_star_24', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___atomic_clause_list_star_24', '__type__': 'NonTerminal'}, {'name': '_atomic_clause', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1691: {'origin': {'name': '__apply_clause_arg_star_25', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_apply_directive', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1692: {'origin': {'name': '__apply_clause_arg_star_25', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__apply_clause_arg_star_25', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_apply_directive', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1693: {'origin': {'name': '___depend_modifier_list_star_26', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_depend_modifier', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1694: {'origin': {'name': '___depend_modifier_list_star_26', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___depend_modifier_list_star_26', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_depend_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1695: {'origin': {'name': '___reduction_modifier_list_star_27', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_reduction_modifier', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1696: {'origin': {'name': '___reduction_modifier_list_star_27', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___reduction_modifier_list_star_27', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_reduction_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1697: {'origin': {'name': '___allocate_modifier_list_star_28', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_allocate_modifier', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1698: {'origin': {'name': '___allocate_modifier_list_star_28', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___allocate_modifier_list_star_28', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_allocate_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1699: {'origin': {'name': '___map_modifier_list_star_29', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_map_modifier', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1700: {'origin': {'name': '___map_modifier_list_star_29', '__type__': 'NonTerminal'}, 'expansion': [{'name': '___map_modifier_list_star_29', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': '_map_modifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1701: {'origin': {'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PY_CODE_OUT', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1702: {'origin': {'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_code_in', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1703: {'origin': {'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1704: {'origin': {'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LBRACE', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_code_in', '__type__': 'NonTerminal'}, {'name': 'RBRACE', 'filter_out': True, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1705: {'origin': {'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LBRACE', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'RBRACE', 'filter_out': True, '__type__': 'Terminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1706: {'origin': {'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LSQB', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_code_in', '__type__': 'NonTerminal'}, {'name': 'RSQB', 'filter_out': True, '__type__': 'Terminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1707: {'origin': {'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LSQB', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'RSQB', 'filter_out': True, '__type__': 'Terminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1708: {'origin': {'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, {'name': 'PY_CODE_OUT', 'filter_out': False, '__type__': 'Terminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1709: {'origin': {'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_code_in', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1710: {'origin': {'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 9, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1711: {'origin': {'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, {'name': 'LBRACE', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_code_in', '__type__': 'NonTerminal'}, {'name': 'RBRACE', 'filter_out': True, '__type__': 'Terminal'}], 'order': 10, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1712: {'origin': {'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, {'name': 'LBRACE', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'RBRACE', 'filter_out': True, '__type__': 'Terminal'}], 'order': 11, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1713: {'origin': {'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, {'name': 'LSQB', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_code_in', '__type__': 'NonTerminal'}, {'name': 'RSQB', 'filter_out': True, '__type__': 'Terminal'}], 'order': 12, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1714: {'origin': {'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__py_code_out_plus_30', '__type__': 'NonTerminal'}, {'name': 'LSQB', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'RSQB', 'filter_out': True, '__type__': 'Terminal'}], 'order': 13, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1715: {'origin': {'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'PY_CODE_IN', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1716: {'origin': {'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_code_in', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1717: {'origin': {'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1718: {'origin': {'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LBRACE', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_code_in', '__type__': 'NonTerminal'}, {'name': 'RBRACE', 'filter_out': True, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1719: {'origin': {'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LBRACE', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'RBRACE', 'filter_out': True, '__type__': 'Terminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1720: {'origin': {'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LSQB', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_code_in', '__type__': 'NonTerminal'}, {'name': 'RSQB', 'filter_out': True, '__type__': 'Terminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1721: {'origin': {'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'LSQB', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'RSQB', 'filter_out': True, '__type__': 'Terminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1722: {'origin': {'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, {'name': 'PY_CODE_IN', 'filter_out': False, '__type__': 'Terminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1723: {'origin': {'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_code_in', '__type__': 'NonTerminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 8, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1724: {'origin': {'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, {'name': 'LPAR', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'RPAR', 'filter_out': True, '__type__': 'Terminal'}], 'order': 9, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1725: {'origin': {'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, {'name': 'LBRACE', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_code_in', '__type__': 'NonTerminal'}, {'name': 'RBRACE', 'filter_out': True, '__type__': 'Terminal'}], 'order': 10, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1726: {'origin': {'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, {'name': 'LBRACE', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'RBRACE', 'filter_out': True, '__type__': 'Terminal'}], 'order': 11, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1727: {'origin': {'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, {'name': 'LSQB', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_code_in', '__type__': 'NonTerminal'}, {'name': 'RSQB', 'filter_out': True, '__type__': 'Terminal'}], 'order': 12, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1728: {'origin': {'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__py_code_in_plus_31', '__type__': 'NonTerminal'}, {'name': 'LSQB', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'RSQB', 'filter_out': True, '__type__': 'Terminal'}], 'order': 13, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1729: {'origin': {'name': '__var_list_star_32', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1730: {'origin': {'name': '__var_list_star_32', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__var_list_star_32', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'IDENTIFIER', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1731: {'origin': {'name': '__expr_list_star_33', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1732: {'origin': {'name': '__expr_list_star_33', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__expr_list_star_33', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_expr', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1733: {'origin': {'name': '__type_list_star_34', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_type', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1734: {'origin': {'name': '__type_list_star_34', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__type_list_star_34', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_type', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1735: {'origin': {'name': '__stmt_list_star_35', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_stmt', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1736: {'origin': {'name': '__stmt_list_star_35', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__stmt_list_star_35', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'py_stmt', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1737: {'origin': {'name': '__iterator_modifier_star_36', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'iterator_specifier', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1738: {'origin': {'name': '__iterator_modifier_star_36', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__iterator_modifier_star_36', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'iterator_specifier', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1739: {'origin': {'name': '__prefer_type_modifier_star_37', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'preference_specification', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1740: {'origin': {'name': '__prefer_type_modifier_star_37', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__prefer_type_modifier_star_37', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'preference_specification', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1741: {'origin': {'name': '__preference_specification_star_38', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'fr_selector', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1742: {'origin': {'name': '__preference_specification_star_38', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'attr_selector', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1743: {'origin': {'name': '__preference_specification_star_38', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__preference_specification_star_38', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'fr_selector', '__type__': 'NonTerminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 1744: {'origin': {'name': '__preference_specification_star_38', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__preference_specification_star_38', '__type__': 'NonTerminal'}, {'name': 'COMMA', 'filter_out': True, '__type__': 'Terminal'}, {'name': 'attr_selector', '__type__': 'NonTerminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}} +) +Shift = 0 +Reduce = 1 +def Lark_StandAlone(**kwargs): + return Lark._load_from_dict(DATA, MEMO, **kwargs) diff --git a/omp4py/core/parser/parser.py b/omp4py/core/parser/parser.py index 1b79594..cea42d1 100644 --- a/omp4py/core/parser/parser.py +++ b/omp4py/core/parser/parser.py @@ -21,11 +21,44 @@ from __future__ import annotations import ast +import typing +from pathlib import Path -from omp4py.core.parser.tree import Directive, Span +from . import openmp_parser as omp +from . import string_parser as pre + +from .source_view import SourceView +from .transformer import AstTransformer +from .tree import Directive, Span __all__ = ["extract_directive", "parse_directive", "syntax_error"] +@pre.v_args(inline=True) +class PreTransformer(pre.Transformer): + def scape_seq(self, token: pre.Token) -> str: + return " "*len(str(token)) + + def string_token(self, token: pre.Token) -> str: + return str(token) + + @pre.v_args(inline=False) + def string_literal(self, children: list) -> str: + return ( + " "*len(str(children[0])) + + "".join(children[1:-1]) + + " "*len(str(children[-1])) + ) + + @pre.v_args(inline=False) + def start(self, children: list) -> str: + if len(children) == 1: + return children[0] + assert len(children) == 2 + return " "*len(str(children[0])) + children[1] + +preprocesor = pre.Lark_StandAlone(transformer=PreTransformer()) +openmp_parser = omp.Lark_StandAlone() + def syntax_error(message: str, span: Span, source: str, filename: str) -> SyntaxError: """Create a syntax error associated with a source code span. @@ -88,8 +121,21 @@ def extract_directive(node: ast.Constant, full_source: str, filename: str) -> st if len(raw_source) - 2 == len(node_value): return node_value - msg = "Complex directives is not supported yet" - raise NotImplementedError(msg) + return preprocesor.parse(raw_source) + + +# Required for the tests, to avoid duplicating the error handling +def _parse(code: str, source_view: SourceView) -> Directive: + transformer = AstTransformer(source_view) + try: + parse_tree = openmp_parser.parse(code) + return transformer.transform(parse_tree) + except omp.UnexpectedToken as e: + raise source_view.error(e) from None + except omp.VisitError as e: + if isinstance(e.orig_exc, SyntaxError): + raise e.orig_exc from None + raise def parse_directive(code: str, span: Span, filename: str) -> Directive: @@ -113,6 +159,12 @@ def parse_directive(code: str, span: Span, filename: str) -> Directive: Returns: Directive: Parsed directive representation. + + Raises: + SyntaxError if the directive is incorrect. """ - msg = "New parser is not implemented yet" - raise NotImplementedError(msg) + source_view = SourceView.from_file(span, filename, code) + return _parse(code, source_view) + + + diff --git a/omp4py/core/parser/source_view.py b/omp4py/core/parser/source_view.py new file mode 100644 index 0000000..952f715 --- /dev/null +++ b/omp4py/core/parser/source_view.py @@ -0,0 +1,415 @@ +"""Source access and diagnostics for OpenMP directive parsing. + +This module provides utilities to map parser and AST diagnostics back to the +original Python source code containing an ``omp()`` directive. + +It defines ``SourceView``, which swns the source text and provides helpers to: + +* Extract source fragments +* Build annotated ``SyntaxError`` instances + +Line numbers are 1-based and column offsets are 0-based, matching Python's +``SyntaxError`` conventions. + +This module does not perform parsing; it only formats and contextualizes +errors produced by the parser. +""" +from __future__ import annotations +from cmath import exp + +import typing +from dataclasses import dataclass +from pathlib import Path + +from .tree import Span + +if typing.TYPE_CHECKING: + from .openmp_parser import Token, Meta, UnexpectedToken + +__all__ = ["SourceView"] + +# Look up table to translate token names to a more meaningfull name. +# Defaults to lowercase the name of the token with double quotes. +_TOKEN_DISPLAY: dict[str, str] = { + # Reduction operators + "PLUS" : '"+"', + "MINUS" : '"-"', + "MULT" : '"*"', + "BITWISE_AND" : '"&"', + "BITWISE_OR" : '"|"', + "BITWISE_XOR" : '"^"', + "LOGIC_AND" : '"and"', + "LOGIC_OR" : '"or"', + "MAX" : '"max"', + "MIN" : '"min"', + + # Other + "INTEGER" : "integer", + "IDENTIFIER" : "variable name", + + # Defined by Lark + "LPAR" : '"("', + "RPAR" : '")"', + "LBRACE": '"{"', + "RBRACE": '"}"', + "LSQB" : '"["', + "RSQB" : '"]"', + "COMMA" : '","', + "COLON" : '":"', + "$END" : "end of input", +} + + +class SourceView: + """View and query helper for directive source code. + + This class encapsulates access to the original source code associated with + an ``omp()`` directive invocation. It stores the full file contents and + provides utilities to: + + - Extract text fragments using line/column spans + - Compute absolute positions for diagnostics + - Construct rich ``SyntaxError`` objects with annotations and notes + + All line numbers are 1-based, and column offsets are 0-based, matching + Python's ``SyntaxError`` conventions. + """ + def __init__( + self, + span: Span, + filename: str, + lines: list[str], + directive: str + ) -> None: + self.span = span + self.filename = filename + self.lines = lines + self.directive = directive + + @staticmethod + def from_file(span: Span, filename: str, directive: str) -> SourceView: + """Construct a SourceView by loading source lines from a file. + + Args: + span (tree.Span): Span locating the directive in the file. + filename (str): Path to the source file. + directive (str): Raw text of the directive. + Returns: + SourceView: A new instance populated with the file contents. + """ + return SourceView( + span, + filename, + Path(filename).read_text().splitlines(), + directive, + ) + + #### TEXT RETRIEVAL ######################################################## + + def source_line(self, lineno: int) -> str: + """Return a single line of source code. + + Args: + lineno (int): 1-based line number. + Returns: + str: The corresponding line of source code. + """ + if not self.lines: + return '' + return self.lines[lineno - 1] + + def source_text(self, span: Span) -> str: + """Extract source text referenced by a span. + + Args: + span (tree.Span): Span identifying a region of the source file. + Returns: + str: The concatenated source text covered by the span. + """ + if span.lineno == span.end_lineno: + return self.lines[span.lineno - 1][span.offset:span.end_offset] + + parts = [self.lines[span.lineno - 1][span.offset:]] + parts.extend(self.lines[span.lineno:span.end_lineno - 1]) + parts.append(self.lines[span.end_lineno - 1][:span.end_offset]) + + return "\n".join(parts) + + #### POSITION TRANSFORMATION ############################################### + + def token2span(self, token: Token) -> Span: + if token.line is None or token.column is None: + msg = "Missing position information" + raise ValueError(msg) + + # Lark starts at line 1 column 1, but the Span expects an offset. + line_offset = max(self.span.lineno, 1) + start_col_offset = self.span.offset if token.line == 1 else 0 + end_col_offset = self.span.offset if token.end_line == 1 else 0 + + return Span( + line_offset + token.line - 1, + start_col_offset + token.column - 1, + line_offset + token.end_line - 1 if token.end_line is not None else -1, + end_col_offset + token.end_column - 1 if token.end_column is not None else -1, + ) + + def meta2span(self, meta: Meta) -> Span: + if meta.empty: + msg = "Meta object is empty" + raise ValueError(msg) + + line_offset = max(self.span.lineno, 1) + start_col_offset = self.span.offset if meta.line == 1 else 0 + end_col_offset = self.span.offset if meta.end_line == 1 else 0 + + return Span( + line_offset + meta.line - 1, + start_col_offset + meta.column - 1, + line_offset + meta.end_line - 1, + end_col_offset + meta.end_column - 1, + ) + + def absolute_position( + self, + anchor: Span, + rel_line: int, + rel_col: int, + first_offset: int = 0, + ) -> tuple[int, int]: + """Convert a position relative to an anchor span into absolute coordinates. + + No validation is performed. + + Args: + anchor (tree.Span): Anchor span. + rel_line (int): Line number relative to the anchor (1-based). + rel_col (int): Column number relative to the anchor (1-based). + first_offset (int): Additional column offset applied only if ``rel_line == 1``. + Returns: + tuple[int, int]: Absolute (line, column) position in the source file. + """ + abs_line = anchor.lineno + rel_line - 1 + abs_col = ( + anchor.offset + first_offset + rel_col - 1 # offset only applies on the first line + if rel_line == 1 + else rel_col - 1 + ) + return abs_line, abs_col + + + #### ERRORS ################################################################ + + def syntax_error( + self, + message, + span: Span, + *, + diagnostics: list[tuple[str, Span]|str] | None = None, + ) -> SyntaxError: + """Construct a ``SyntaxError`` with optional diagnostic notes. + + Args: + message (str): Error message. + span (tree.Span): Span identifying the error location. + diagnostics: Optional list of (message, span) pairs used to generate additional annotated notes. + Returns: + SyntaxError: A fully populated ``SyntaxError`` instance. + """ + text = self.source_line(span.lineno) + + error: SyntaxError + if span.end_lineno < 0 or span.end_offset < 0: + error = SyntaxError( + message, + (self.filename, span.lineno, span.offset + 1, text), + ) + else: + error = SyntaxError( + message, + (self.filename, span.lineno, span.offset + 1, text, span.end_lineno, span.end_offset + 1), + ) + + if diagnostics is not None: + for diag in diagnostics: + if isinstance(diag, str): + error.add_note(f" note: {diag}") + else: + msg, span = diag + line, cursor = self.annotate(span, indent=2, show_lineno=True) + error.add_note(f" note: {msg}\n{line}{cursor[:-1]}") + + return error + + + def error( + self, + error: UnexpectedToken, + diagnostics: list[tuple[str, Span]|str] | None = None, + ) -> SyntaxError: + """Convert a parser ``UnexpectedToken`` into a ``SyntaxError``. + + Args: + error (lark.exceptions.UnexpectedToken): Parser error raised by Lark. + diagnostics: Optional diagnostic notes forwarded to :meth:`syntax_error`. + Returns: + SyntaxError: A formatted syntax error suitable for user display. + """ + token = typing.cast("Token", error.token) + msg, span = self._msg_from_error(error, self.token2span(token)) + return self.syntax_error(msg, span, diagnostics=diagnostics) + + + def _msg_from_error(self, error: UnexpectedToken, span: Span) -> tuple[str, Span]: + token = typing.cast("Token", error.token) + + #### Expected tokens #### + + expected_token_names: list[str] = [] + expected_directive = False + expected_clause = False + expected_code = False + expected_end = False + + for expected_token in error.expected: + if expected_token.endswith("_DIRECTIVE"): + expected_directive = True + continue + + if expected_token.endswith("_CLAUSE"): + expected_clause = True + continue + + if expected_token == "PY_CODE_IN" or expected_token == "PY_CODE_OUT": + expected_code = True + continue + + if expected_token == "": + expected_end = True + continue + + expected_token_names.append(_TOKEN_DISPLAY.get(expected_token, f'"{expected_token.lower()}"')) + + # Make sure these are last + if expected_clause: + expected_token_names.append("OpenMP clause") + if expected_directive: + expected_token_names.append("OpenMP directive") + + # Convert to expected_str + expected_token_names = sorted(expected_token_names) + if len(expected_token_names) == 0: + expected_str = "OpenMP directive" + elif len(expected_token_names) == 1: + expected_str = expected_token_names[0] + else: + expected_str = ", ".join(expected_token_names[:-1]) + f" or {expected_token_names[-1]}" + + + #### Actual token received #### + found_token = _TOKEN_DISPLAY.get(token.type, f'"{token}"') + last_token = typing.cast("Token", error.token_history[-1] if error.token_history else None) + + if last_token: + assert last_token.column is not None + assert last_token.column is not None + assert last_token.end_column is not None + assert token.column is not None + + # If the current token is an identifier and the last token was an integer, + # it is probably because the integer was invalid and the lexer broke it into parts: + # "0o9" ==> integer 0 + "o9" identifier + # "0o19" ==> integer 1 + "9" integer + # This is only applies if both tokens are next to each other with no whitespace in between, + # because "0 o9" should get a different error. + if ( + (token.type == "IDENTIFIER" or token.type == "INTEGER") and + last_token.type == "INTEGER" and + last_token.line == token.line and last_token.end_column == token.column + ): + start_col_offset = self.span.offset if last_token.line == 1 else 0 + span.offset = start_col_offset + last_token.column - 1 + return f'invalid integer literal "{last_token}{token}".', span + + # Something similar can happen for the directives and clauses' keywords. + # The lexer only considers tokens that are valid in the current state, + # so there are cases where they can be mixed up. + # For example, parallel accepts the default clause, not the defaultmap: + # File "", line 8 + # with omp("parallel defaultmap(none)"): + # ^^^ + # SyntaxError: expected "(" before "map". + # The expected error here should be that the clause is invalid. + # + # So, if a *_DIRECTIVE/*_CLAUSE token is immediately followed by another token + # with no whitespace between them, the contextual lexer may have split a + # longer keyword into a short one it did recognize here, plus leftover garbage. + if ( + (token.type.endswith(("_DIRECTIVE", "_CLAUSE")) or token.type == "IDENTIFIER") and + last_token.type.endswith(("_DIRECTIVE", "_CLAUSE")) and + last_token.line == token.line and last_token.end_column == token.column + ): + start_col_offset = self.span.offset if last_token.line == 1 else 0 + span.offset = start_col_offset + last_token.column - 1 + return f'{last_token}{token} clause is invalid for this directive.', span + + if expected_clause and (token.type.endswith(("_DIRECTIVE", "_CLAUSE")) or token.type == "IDENTIFIER"): + return f'{token} clause is invalid for this directive.', span + + if expected_end and token.type.endswith("_CLAUSE"): + return f'this directive does not accept any clauses.', span + + # If the token is PY_CODE, it means that we got unexpected characters. + # The problem here is that PY_CODE will consume everything until a parentheses, + # therefore the error location will be wrong. + # Only point to the first incorrect caracter. + if token.type == "PY_CODE_IN" or token.type == "PY_CODE_OUT": + first_char = token[0] + display = "integer" if first_char.isdigit() else f"'{first_char}'" + span.end_offset = span.offset + span.end_lineno = span.lineno + return f'expected {expected_str} instead of {display}.', span + + # If we expected a directive and the token was a directive, + # it means that this directive was incorrect + if expected_directive and token.type.endswith("_DIRECTIVE"): + return f'{token} directive is invalid here.', span + + if expected_directive and expected_clause: + return f"expected OpenMP clause or directive before {found_token}.", span + + if expected_code: + return f"expected Python expression before {found_token}.", span + + return f"expected {expected_str} before {found_token}.", span + + + def annotate(self, span: Span, indent: int=0, show_lineno: bool=False) -> tuple[str, str]: + """Generate an annotated source line and cursor indicator. + + Args: + span (tree.Span): Span to highlight. + indent (int): Number of spaces to indent both line and cursor. + show_lineno (bool): Whether to prefix the line with its line number. + Returns: + tuple[str, str]: (source line, cursor line) + """ + + line = self.lines[span.lineno - 1] + "\n" + width = ( + span.end_offset - span.offset + if span.lineno == span.end_lineno + else len(line) - span.offset + ) + cursor = " " * span.offset + "^" * width + "\n" + + if show_lineno: + line = f"{span.lineno:>5} | {line}" + cursor = " "*5 + " | " + cursor + + line = " " * indent + line + cursor = " " * indent + cursor + + return line, cursor + + diff --git a/omp4py/core/parser/string.lark b/omp4py/core/parser/string.lark new file mode 100644 index 0000000..da09049 --- /dev/null +++ b/omp4py/core/parser/string.lark @@ -0,0 +1,49 @@ +////////////////////////////////////////////////////////////////////////////////// +// // +// To generate the string parser from this grammar use the following command: // +// // +// python -m lark.tools.standalone string_literal.lark \ // +// --out string_parser.py --lexer basic --start start // +// // +////////////////////////////////////////////////////////////////////////////////// + +// ---- TOKENS ----------------------------------------------------------------- + +OCTAL_DIGIT.5 : "0".."7" +HEX_DIGIT.5 : "0".."9" | "a".."f" | "A".."F" +OCTAL_SCAPE.5 : "\\" OCTAL_DIGIT~1..3 +HEX_SCAPE.5 : "\\x" HEX_DIGIT~2 + +UNICODE_SCAPE.5 : "\\U" HEX_DIGIT~8 | "\\u" HEX_DIGIT~4 +NAMED_UNICODE_SCAPE.5 : "\\N{" NAME "}" +NAME.5 : /[a-zA-Z0-9 \-]+/ + +NEWLINE.5 : "\n" +STRING_PREFIX.5 : "r"i | "u"i | "b"i | "br"i | "rb"i + +TRIPLE_DOUBLE.4 : "\"\"\"" +TRIPLE_SINGLE.4 : "'''" +DOUBLE.3 : "\"" +SINGLE.3 : "'" + +SINGLE_SCAPE_SEQ.2 : /\\[\n\\\'\"abfnrtv]/ +UNRECOGNIZED_SCAPE_SEQ.1 : /\\./s + +ANY.0: /[^\"'\\\n]+/s + +// ---- RULES ------------------------------------------------------------------ + +start: STRING_PREFIX? string_literal +string_literal: TRIPLE_DOUBLE triple_double_inner* TRIPLE_DOUBLE + | TRIPLE_SINGLE triple_single_inner* TRIPLE_SINGLE + | DOUBLE double_inner* DOUBLE + | SINGLE single_inner* SINGLE + +?triple_double_inner : other_token | TRIPLE_SINGLE | DOUBLE | SINGLE | NEWLINE -> string_token +?triple_single_inner : other_token | TRIPLE_DOUBLE | DOUBLE | SINGLE | NEWLINE -> string_token +?double_inner : other_token | TRIPLE_DOUBLE | TRIPLE_SINGLE | SINGLE -> string_token +?single_inner : other_token | TRIPLE_DOUBLE | TRIPLE_SINGLE | DOUBLE -> string_token + +?other_token: scape_seq | UNRECOGNIZED_SCAPE_SEQ | STRING_PREFIX | ANY +scape_seq: SINGLE_SCAPE_SEQ | OCTAL_SCAPE | HEX_SCAPE | NAMED_UNICODE_SCAPE | UNICODE_SCAPE + diff --git a/omp4py/core/parser/string_parser.py b/omp4py/core/parser/string_parser.py new file mode 100644 index 0000000..f7e8cc8 --- /dev/null +++ b/omp4py/core/parser/string_parser.py @@ -0,0 +1,3572 @@ +# The file was automatically generated by Lark v1.3.1 +__version__ = "1.3.1" + +# +# +# Lark Stand-alone Generator Tool +# ---------------------------------- +# Generates a stand-alone LALR(1) parser +# +# Git: https://github.com/erezsh/lark +# Author: Erez Shinan (erezshin@gmail.com) +# +# +# >>> LICENSE +# +# This tool and its generated code use a separate license from Lark, +# and are subject to the terms of the Mozilla Public License, v. 2.0. +# If a copy of the MPL was not distributed with this +# file, You can obtain one at https://mozilla.org/MPL/2.0/. +# +# If you wish to purchase a commercial license for this tool and its +# generated code, you may contact me via email or otherwise. +# +# If MPL2 is incompatible with your free or open-source project, +# contact me and we'll work it out. +# +# + +from copy import deepcopy +from abc import ABC, abstractmethod +from types import ModuleType +from typing import ( + TypeVar, Generic, Type, Tuple, List, Dict, Iterator, Collection, Callable, Optional, FrozenSet, Any, + Union, Iterable, IO, TYPE_CHECKING, overload, Sequence, + Pattern as REPattern, ClassVar, Set, Mapping +) + + +class LarkError(Exception): + pass + + +class ConfigurationError(LarkError, ValueError): + pass + + +def assert_config(value, options: Collection, msg='Got %r, expected one of %s'): + if value not in options: + raise ConfigurationError(msg % (value, options)) + + +class GrammarError(LarkError): + pass + + +class ParseError(LarkError): + pass + + +class LexError(LarkError): + pass + +T = TypeVar('T') + +class UnexpectedInput(LarkError): + #-- + line: int + column: int + pos_in_stream = None + state: Any + _terminals_by_name = None + interactive_parser: 'InteractiveParser' + + def get_context(self, text: str, span: int=40) -> str: + #-- + pos = self.pos_in_stream or 0 + start = max(pos - span, 0) + end = pos + span + if not isinstance(text, bytes): + before = text[start:pos].rsplit('\n', 1)[-1] + after = text[pos:end].split('\n', 1)[0] + return before + after + '\n' + ' ' * len(before.expandtabs()) + '^\n' + else: + before = text[start:pos].rsplit(b'\n', 1)[-1] + after = text[pos:end].split(b'\n', 1)[0] + return (before + after + b'\n' + b' ' * len(before.expandtabs()) + b'^\n').decode("ascii", "backslashreplace") + + def match_examples(self, parse_fn: 'Callable[[str], Tree]', + examples: Union[Mapping[T, Iterable[str]], Iterable[Tuple[T, Iterable[str]]]], + token_type_match_fallback: bool=False, + use_accepts: bool=True + ) -> Optional[T]: + #-- + assert self.state is not None, "Not supported for this exception" + + if isinstance(examples, Mapping): + examples = examples.items() + + candidate = (None, False) + for i, (label, example) in enumerate(examples): + assert not isinstance(example, str), "Expecting a list" + + for j, malformed in enumerate(example): + try: + parse_fn(malformed) + except UnexpectedInput as ut: + if ut.state == self.state: + if ( + use_accepts + and isinstance(self, UnexpectedToken) + and isinstance(ut, UnexpectedToken) + and ut.accepts != self.accepts + ): + logger.debug("Different accepts with same state[%d]: %s != %s at example [%s][%s]" % + (self.state, self.accepts, ut.accepts, i, j)) + continue + if ( + isinstance(self, (UnexpectedToken, UnexpectedEOF)) + and isinstance(ut, (UnexpectedToken, UnexpectedEOF)) + ): + if ut.token == self.token: ## + + logger.debug("Exact Match at example [%s][%s]" % (i, j)) + return label + + if token_type_match_fallback: + ## + + if (ut.token.type == self.token.type) and not candidate[-1]: + logger.debug("Token Type Fallback at example [%s][%s]" % (i, j)) + candidate = label, True + + if candidate[0] is None: + logger.debug("Same State match at example [%s][%s]" % (i, j)) + candidate = label, False + + return candidate[0] + + def _format_expected(self, expected): + if self._terminals_by_name: + d = self._terminals_by_name + expected = [d[t_name].user_repr() if t_name in d else t_name for t_name in expected] + return "Expected one of: \n\t* %s\n" % '\n\t* '.join(expected) + + +class UnexpectedEOF(ParseError, UnexpectedInput): + #-- + expected: 'List[Token]' + + def __init__(self, expected, state=None, terminals_by_name=None): + super(UnexpectedEOF, self).__init__() + + self.expected = expected + self.state = state + from .lexer import Token + self.token = Token("", "") ## + + self.pos_in_stream = -1 + self.line = -1 + self.column = -1 + self._terminals_by_name = terminals_by_name + + + def __str__(self): + message = "Unexpected end-of-input. " + message += self._format_expected(self.expected) + return message + + +class UnexpectedCharacters(LexError, UnexpectedInput): + #-- + + allowed: Set[str] + considered_tokens: Set[Any] + + def __init__(self, seq, lex_pos, line, column, allowed=None, considered_tokens=None, state=None, token_history=None, + terminals_by_name=None, considered_rules=None): + super(UnexpectedCharacters, self).__init__() + + ## + + self.line = line + self.column = column + self.pos_in_stream = lex_pos + self.state = state + self._terminals_by_name = terminals_by_name + + self.allowed = allowed + self.considered_tokens = considered_tokens + self.considered_rules = considered_rules + self.token_history = token_history + + if isinstance(seq, bytes): + self.char = seq[lex_pos:lex_pos + 1].decode("ascii", "backslashreplace") + else: + self.char = seq[lex_pos] + self._context = self.get_context(seq) + + + def __str__(self): + message = "No terminal matches '%s' in the current parser context, at line %d col %d" % (self.char, self.line, self.column) + message += '\n\n' + self._context + if self.allowed: + message += self._format_expected(self.allowed) + if self.token_history: + message += '\nPrevious tokens: %s\n' % ', '.join(repr(t) for t in self.token_history) + return message + + +class UnexpectedToken(ParseError, UnexpectedInput): + #-- + + expected: Set[str] + considered_rules: Set[str] + + def __init__(self, token, expected, considered_rules=None, state=None, interactive_parser=None, terminals_by_name=None, token_history=None): + super(UnexpectedToken, self).__init__() + + ## + + self.line = getattr(token, 'line', '?') + self.column = getattr(token, 'column', '?') + self.pos_in_stream = getattr(token, 'start_pos', None) + self.state = state + + self.token = token + self.expected = expected ## + + self._accepts = NO_VALUE + self.considered_rules = considered_rules + self.interactive_parser = interactive_parser + self._terminals_by_name = terminals_by_name + self.token_history = token_history + + + @property + def accepts(self) -> Set[str]: + if self._accepts is NO_VALUE: + self._accepts = self.interactive_parser and self.interactive_parser.accepts() + return self._accepts + + def __str__(self): + message = ("Unexpected token %r at line %s, column %s.\n%s" + % (self.token, self.line, self.column, self._format_expected(self.accepts or self.expected))) + if self.token_history: + message += "Previous tokens: %r\n" % self.token_history + + return message + + + +class VisitError(LarkError): + #-- + + obj: 'Union[Tree, Token]' + orig_exc: Exception + + def __init__(self, rule, obj, orig_exc): + message = 'Error trying to process rule "%s":\n\n%s' % (rule, orig_exc) + super(VisitError, self).__init__(message) + + self.rule = rule + self.obj = obj + self.orig_exc = orig_exc + + +class MissingVariableError(LarkError): + pass + + +import sys, re +import logging +from dataclasses import dataclass +from typing import Generic, AnyStr + +logger: logging.Logger = logging.getLogger("lark") +logger.addHandler(logging.StreamHandler()) +## + +## + +logger.setLevel(logging.CRITICAL) + + +NO_VALUE = object() + +T = TypeVar("T") + + +def classify(seq: Iterable, key: Optional[Callable] = None, value: Optional[Callable] = None) -> Dict: + d: Dict[Any, Any] = {} + for item in seq: + k = key(item) if (key is not None) else item + v = value(item) if (value is not None) else item + try: + d[k].append(v) + except KeyError: + d[k] = [v] + return d + + +def _deserialize(data: Any, namespace: Dict[str, Any], memo: Dict) -> Any: + if isinstance(data, dict): + if '__type__' in data: ## + + class_ = namespace[data['__type__']] + return class_.deserialize(data, memo) + elif '@' in data: + return memo[data['@']] + return {key:_deserialize(value, namespace, memo) for key, value in data.items()} + elif isinstance(data, list): + return [_deserialize(value, namespace, memo) for value in data] + return data + + +_T = TypeVar("_T", bound="Serialize") + +class Serialize: + #-- + + def memo_serialize(self, types_to_memoize: List) -> Any: + memo = SerializeMemoizer(types_to_memoize) + return self.serialize(memo), memo.serialize() + + def serialize(self, memo = None) -> Dict[str, Any]: + if memo and memo.in_types(self): + return {'@': memo.memoized.get(self)} + + fields = getattr(self, '__serialize_fields__') + res = {f: _serialize(getattr(self, f), memo) for f in fields} + res['__type__'] = type(self).__name__ + if hasattr(self, '_serialize'): + self._serialize(res, memo) + return res + + @classmethod + def deserialize(cls: Type[_T], data: Dict[str, Any], memo: Dict[int, Any]) -> _T: + namespace = getattr(cls, '__serialize_namespace__', []) + namespace = {c.__name__:c for c in namespace} + + fields = getattr(cls, '__serialize_fields__') + + if '@' in data: + return memo[data['@']] + + inst = cls.__new__(cls) + for f in fields: + try: + setattr(inst, f, _deserialize(data[f], namespace, memo)) + except KeyError as e: + raise KeyError("Cannot find key for class", cls, e) + + if hasattr(inst, '_deserialize'): + inst._deserialize() + + return inst + + +class SerializeMemoizer(Serialize): + #-- + + __serialize_fields__ = 'memoized', + + def __init__(self, types_to_memoize: List) -> None: + self.types_to_memoize = tuple(types_to_memoize) + self.memoized = Enumerator() + + def in_types(self, value: Serialize) -> bool: + return isinstance(value, self.types_to_memoize) + + def serialize(self) -> Dict[int, Any]: ## + + return _serialize(self.memoized.reversed(), None) + + @classmethod + def deserialize(cls, data: Dict[int, Any], namespace: Dict[str, Any], memo: Dict[Any, Any]) -> Dict[int, Any]: ## + + return _deserialize(data, namespace, memo) + + +try: + import regex + _has_regex = True +except ImportError: + _has_regex = False + +if sys.version_info >= (3, 11): + import re._parser as sre_parse + import re._constants as sre_constants +else: + import sre_parse + import sre_constants + +categ_pattern = re.compile(r'\\p{[A-Za-z_]+}') + +def get_regexp_width(expr: str) -> Union[Tuple[int, int], List[int]]: + if _has_regex: + ## + + ## + + ## + + regexp_final = re.sub(categ_pattern, 'A', expr) + else: + if re.search(categ_pattern, expr): + raise ImportError('`regex` module must be installed in order to use Unicode categories.', expr) + regexp_final = expr + try: + ## + + return [int(x) for x in sre_parse.parse(regexp_final).getwidth()] + except sre_constants.error: + if not _has_regex: + raise ValueError(expr) + else: + ## + + ## + + c = regex.compile(regexp_final) + ## + + ## + + MAXWIDTH = getattr(sre_parse, "MAXWIDTH", sre_constants.MAXREPEAT) + if c.match('') is None: + ## + + return 1, int(MAXWIDTH) + else: + return 0, int(MAXWIDTH) + + +@dataclass(frozen=True) +class TextSlice(Generic[AnyStr]): + #-- + text: AnyStr + start: int + end: int + + def __post_init__(self): + if not isinstance(self.text, (str, bytes)): + raise TypeError("text must be str or bytes") + + if self.start < 0: + object.__setattr__(self, 'start', self.start + len(self.text)) + assert self.start >=0 + + if self.end is None: + object.__setattr__(self, 'end', len(self.text)) + elif self.end < 0: + object.__setattr__(self, 'end', self.end + len(self.text)) + assert self.end <= len(self.text) + + @classmethod + def cast_from(cls, text: 'TextOrSlice') -> 'TextSlice[AnyStr]': + if isinstance(text, TextSlice): + return text + + return cls(text, 0, len(text)) + + def is_complete_text(self): + return self.start == 0 and self.end == len(self.text) + + def __len__(self): + return self.end - self.start + + def count(self, substr: AnyStr): + return self.text.count(substr, self.start, self.end) + + def rindex(self, substr: AnyStr): + return self.text.rindex(substr, self.start, self.end) + + +TextOrSlice = Union[AnyStr, 'TextSlice[AnyStr]'] +LarkInput = Union[AnyStr, TextSlice[AnyStr], Any] + + + +class Meta: + + empty: bool + line: int + column: int + start_pos: int + end_line: int + end_column: int + end_pos: int + orig_expansion: 'List[TerminalDef]' + match_tree: bool + + def __init__(self): + self.empty = True + + +_Leaf_T = TypeVar("_Leaf_T") +Branch = Union[_Leaf_T, 'Tree[_Leaf_T]'] + + +class Tree(Generic[_Leaf_T]): + #-- + + data: str + children: 'List[Branch[_Leaf_T]]' + + def __init__(self, data: str, children: 'List[Branch[_Leaf_T]]', meta: Optional[Meta]=None) -> None: + self.data = data + self.children = children + self._meta = meta + + @property + def meta(self) -> Meta: + if self._meta is None: + self._meta = Meta() + return self._meta + + def __repr__(self): + return 'Tree(%r, %r)' % (self.data, self.children) + + __match_args__ = ("data", "children") + + def _pretty_label(self): + return self.data + + def _pretty(self, level, indent_str): + yield f'{indent_str*level}{self._pretty_label()}' + if len(self.children) == 1 and not isinstance(self.children[0], Tree): + yield f'\t{self.children[0]}\n' + else: + yield '\n' + for n in self.children: + if isinstance(n, Tree): + yield from n._pretty(level+1, indent_str) + else: + yield f'{indent_str*(level+1)}{n}\n' + + def pretty(self, indent_str: str=' ') -> str: + #-- + return ''.join(self._pretty(0, indent_str)) + + def __rich__(self, parent:Optional['rich.tree.Tree']=None) -> 'rich.tree.Tree': + #-- + return self._rich(parent) + + def _rich(self, parent): + if parent: + tree = parent.add(f'[bold]{self.data}[/bold]') + else: + import rich.tree + tree = rich.tree.Tree(self.data) + + for c in self.children: + if isinstance(c, Tree): + c._rich(tree) + else: + tree.add(f'[green]{c}[/green]') + + return tree + + def __eq__(self, other): + try: + return self.data == other.data and self.children == other.children + except AttributeError: + return False + + def __ne__(self, other): + return not (self == other) + + def __hash__(self) -> int: + return hash((self.data, tuple(self.children))) + + def iter_subtrees(self) -> 'Iterator[Tree[_Leaf_T]]': + #-- + queue = [self] + subtrees = dict() + for subtree in queue: + subtrees[id(subtree)] = subtree + queue += [c for c in reversed(subtree.children) + if isinstance(c, Tree) and id(c) not in subtrees] + + del queue + return reversed(list(subtrees.values())) + + def iter_subtrees_topdown(self): + #-- + stack = [self] + stack_append = stack.append + stack_pop = stack.pop + while stack: + node = stack_pop() + if not isinstance(node, Tree): + continue + yield node + for child in reversed(node.children): + stack_append(child) + + def find_pred(self, pred: 'Callable[[Tree[_Leaf_T]], bool]') -> 'Iterator[Tree[_Leaf_T]]': + #-- + return filter(pred, self.iter_subtrees()) + + def find_data(self, data: str) -> 'Iterator[Tree[_Leaf_T]]': + #-- + return self.find_pred(lambda t: t.data == data) + + +from functools import wraps, update_wrapper +from inspect import getmembers, getmro + +_Return_T = TypeVar('_Return_T') +_Return_V = TypeVar('_Return_V') +_Leaf_T = TypeVar('_Leaf_T') +_Leaf_U = TypeVar('_Leaf_U') +_R = TypeVar('_R') +_FUNC = Callable[..., _Return_T] +_DECORATED = Union[_FUNC, type] + +class _DiscardType: + #-- + + def __repr__(self): + return "lark.visitors.Discard" + +Discard = _DiscardType() + +## + + +class _Decoratable: + #-- + + @classmethod + def _apply_v_args(cls, visit_wrapper): + mro = getmro(cls) + assert mro[0] is cls + libmembers = {name for _cls in mro[1:] for name, _ in getmembers(_cls)} + for name, value in getmembers(cls): + + ## + + if name.startswith('_') or (name in libmembers and name not in cls.__dict__): + continue + if not callable(value): + continue + + ## + + if isinstance(cls.__dict__[name], _VArgsWrapper): + continue + + setattr(cls, name, _VArgsWrapper(cls.__dict__[name], visit_wrapper)) + return cls + + def __class_getitem__(cls, _): + return cls + + +class Transformer(_Decoratable, ABC, Generic[_Leaf_T, _Return_T]): + #-- + __visit_tokens__ = True ## + + + def __init__(self, visit_tokens: bool=True) -> None: + self.__visit_tokens__ = visit_tokens + + def _call_userfunc(self, tree, new_children=None): + ## + + children = new_children if new_children is not None else tree.children + try: + f = getattr(self, tree.data) + except AttributeError: + return self.__default__(tree.data, children, tree.meta) + else: + try: + wrapper = getattr(f, 'visit_wrapper', None) + if wrapper is not None: + return f.visit_wrapper(f, tree.data, children, tree.meta) + else: + return f(children) + except GrammarError: + raise + except Exception as e: + raise VisitError(tree.data, tree, e) + + def _call_userfunc_token(self, token): + try: + f = getattr(self, token.type) + except AttributeError: + return self.__default_token__(token) + else: + try: + return f(token) + except GrammarError: + raise + except Exception as e: + raise VisitError(token.type, token, e) + + def _transform_children(self, children): + for c in children: + if isinstance(c, Tree): + res = self._transform_tree(c) + elif self.__visit_tokens__ and isinstance(c, Token): + res = self._call_userfunc_token(c) + else: + res = c + + if res is not Discard: + yield res + + def _transform_tree(self, tree): + children = list(self._transform_children(tree.children)) + return self._call_userfunc(tree, children) + + def transform(self, tree: Tree[_Leaf_T]) -> _Return_T: + #-- + res = list(self._transform_children([tree])) + if not res: + return None ## + + assert len(res) == 1 + return res[0] + + def __mul__( + self: 'Transformer[_Leaf_T, Tree[_Leaf_U]]', + other: 'Union[Transformer[_Leaf_U, _Return_V], TransformerChain[_Leaf_U, _Return_V,]]' + ) -> 'TransformerChain[_Leaf_T, _Return_V]': + #-- + return TransformerChain(self, other) + + def __default__(self, data, children, meta): + #-- + return Tree(data, children, meta) + + def __default_token__(self, token): + #-- + return token + + +def merge_transformers(base_transformer=None, **transformers_to_merge): + #-- + if base_transformer is None: + base_transformer = Transformer() + for prefix, transformer in transformers_to_merge.items(): + for method_name in dir(transformer): + method = getattr(transformer, method_name) + if not callable(method): + continue + if method_name.startswith("_") or method_name == "transform": + continue + prefixed_method = prefix + "__" + method_name + if hasattr(base_transformer, prefixed_method): + raise AttributeError("Cannot merge: method '%s' appears more than once" % prefixed_method) + + setattr(base_transformer, prefixed_method, method) + + return base_transformer + + +class InlineTransformer(Transformer): ## + + def _call_userfunc(self, tree, new_children=None): + ## + + children = new_children if new_children is not None else tree.children + try: + f = getattr(self, tree.data) + except AttributeError: + return self.__default__(tree.data, children, tree.meta) + else: + return f(*children) + + +class TransformerChain(Generic[_Leaf_T, _Return_T]): + + transformers: 'Tuple[Union[Transformer, TransformerChain], ...]' + + def __init__(self, *transformers: 'Union[Transformer, TransformerChain]') -> None: + self.transformers = transformers + + def transform(self, tree: Tree[_Leaf_T]) -> _Return_T: + for t in self.transformers: + tree = t.transform(tree) + return cast(_Return_T, tree) + + def __mul__( + self: 'TransformerChain[_Leaf_T, Tree[_Leaf_U]]', + other: 'Union[Transformer[_Leaf_U, _Return_V], TransformerChain[_Leaf_U, _Return_V]]' + ) -> 'TransformerChain[_Leaf_T, _Return_V]': + return TransformerChain(*self.transformers + (other,)) + + +class Transformer_InPlace(Transformer[_Leaf_T, _Return_T]): + #-- + def _transform_tree(self, tree): ## + + return self._call_userfunc(tree) + + def transform(self, tree: Tree[_Leaf_T]) -> _Return_T: + for subtree in tree.iter_subtrees(): + subtree.children = list(self._transform_children(subtree.children)) + + return self._transform_tree(tree) + + +class Transformer_NonRecursive(Transformer[_Leaf_T, _Return_T]): + #-- + + def transform(self, tree: Tree[_Leaf_T]) -> _Return_T: + ## + + rev_postfix = [] + q: List[Branch[_Leaf_T]] = [tree] + while q: + t = q.pop() + rev_postfix.append(t) + if isinstance(t, Tree): + q += t.children + + ## + + stack: List = [] + for x in reversed(rev_postfix): + if isinstance(x, Tree): + size = len(x.children) + if size: + args = stack[-size:] + del stack[-size:] + else: + args = [] + + res = self._call_userfunc(x, args) + if res is not Discard: + stack.append(res) + + elif self.__visit_tokens__ and isinstance(x, Token): + res = self._call_userfunc_token(x) + if res is not Discard: + stack.append(res) + else: + stack.append(x) + + result, = stack ## + + ## + + ## + + ## + + return cast(_Return_T, result) + + +class Transformer_InPlaceRecursive(Transformer[_Leaf_T, _Return_T]): + #-- + def _transform_tree(self, tree): + tree.children = list(self._transform_children(tree.children)) + return self._call_userfunc(tree) + + +## + + +class VisitorBase: + def _call_userfunc(self, tree): + return getattr(self, tree.data, self.__default__)(tree) + + def __default__(self, tree): + #-- + return tree + + def __class_getitem__(cls, _): + return cls + + +class Visitor(VisitorBase, ABC, Generic[_Leaf_T]): + #-- + + def visit(self, tree: Tree[_Leaf_T]) -> Tree[_Leaf_T]: + #-- + for subtree in tree.iter_subtrees(): + self._call_userfunc(subtree) + return tree + + def visit_topdown(self, tree: Tree[_Leaf_T]) -> Tree[_Leaf_T]: + #-- + for subtree in tree.iter_subtrees_topdown(): + self._call_userfunc(subtree) + return tree + + +class Visitor_Recursive(VisitorBase, Generic[_Leaf_T]): + #-- + + def visit(self, tree: Tree[_Leaf_T]) -> Tree[_Leaf_T]: + #-- + for child in tree.children: + if isinstance(child, Tree): + self.visit(child) + + self._call_userfunc(tree) + return tree + + def visit_topdown(self,tree: Tree[_Leaf_T]) -> Tree[_Leaf_T]: + #-- + self._call_userfunc(tree) + + for child in tree.children: + if isinstance(child, Tree): + self.visit_topdown(child) + + return tree + + +class Interpreter(_Decoratable, ABC, Generic[_Leaf_T, _Return_T]): + #-- + + def visit(self, tree: Tree[_Leaf_T]) -> _Return_T: + ## + + ## + + ## + + return self._visit_tree(tree) + + def _visit_tree(self, tree: Tree[_Leaf_T]): + f = getattr(self, tree.data) + wrapper = getattr(f, 'visit_wrapper', None) + if wrapper is not None: + return f.visit_wrapper(f, tree.data, tree.children, tree.meta) + else: + return f(tree) + + def visit_children(self, tree: Tree[_Leaf_T]) -> List: + return [self._visit_tree(child) if isinstance(child, Tree) else child + for child in tree.children] + + def __getattr__(self, name): + return self.__default__ + + def __default__(self, tree): + return self.visit_children(tree) + + +_InterMethod = Callable[[Type[Interpreter], _Return_T], _R] + +def visit_children_decor(func: _InterMethod) -> _InterMethod: + #-- + @wraps(func) + def inner(cls, tree): + values = cls.visit_children(tree) + return func(cls, values) + return inner + +## + + +def _apply_v_args(obj, visit_wrapper): + try: + _apply = obj._apply_v_args + except AttributeError: + return _VArgsWrapper(obj, visit_wrapper) + else: + return _apply(visit_wrapper) + + +class _VArgsWrapper: + #-- + base_func: Callable + + def __init__(self, func: Callable, visit_wrapper: Callable[[Callable, str, list, Any], Any]): + if isinstance(func, _VArgsWrapper): + func = func.base_func + self.base_func = func + self.visit_wrapper = visit_wrapper + update_wrapper(self, func) + + def __call__(self, *args, **kwargs): + return self.base_func(*args, **kwargs) + + def __get__(self, instance, owner=None): + try: + ## + + ## + + g = type(self.base_func).__get__ + except AttributeError: + return self + else: + return _VArgsWrapper(g(self.base_func, instance, owner), self.visit_wrapper) + + def __set_name__(self, owner, name): + try: + f = type(self.base_func).__set_name__ + except AttributeError: + return + else: + f(self.base_func, owner, name) + + +def _vargs_inline(f, _data, children, _meta): + return f(*children) +def _vargs_meta_inline(f, _data, children, meta): + return f(meta, *children) +def _vargs_meta(f, _data, children, meta): + return f(meta, children) +def _vargs_tree(f, data, children, meta): + return f(Tree(data, children, meta)) + + +def v_args(inline: bool = False, meta: bool = False, tree: bool = False, wrapper: Optional[Callable] = None) -> Callable[[_DECORATED], _DECORATED]: + #-- + if tree and (meta or inline): + raise ValueError("Visitor functions cannot combine 'tree' with 'meta' or 'inline'.") + + func = None + if meta: + if inline: + func = _vargs_meta_inline + else: + func = _vargs_meta + elif inline: + func = _vargs_inline + elif tree: + func = _vargs_tree + + if wrapper is not None: + if func is not None: + raise ValueError("Cannot use 'wrapper' along with 'tree', 'meta' or 'inline'.") + func = wrapper + + def _visitor_args_dec(obj): + return _apply_v_args(obj, func) + return _visitor_args_dec + + + +TOKEN_DEFAULT_PRIORITY = 0 + + +class Symbol(Serialize): + __slots__ = ('name',) + + name: str + is_term: ClassVar[bool] = NotImplemented + + def __init__(self, name: str) -> None: + self.name = name + + def __eq__(self, other): + if not isinstance(other, Symbol): + return NotImplemented + return self.is_term == other.is_term and self.name == other.name + + def __ne__(self, other): + return not (self == other) + + def __hash__(self): + return hash(self.name) + + def __repr__(self): + return '%s(%r)' % (type(self).__name__, self.name) + + fullrepr = property(__repr__) + + def renamed(self, f): + return type(self)(f(self.name)) + + +class Terminal(Symbol): + __serialize_fields__ = 'name', 'filter_out' + + is_term: ClassVar[bool] = True + + def __init__(self, name: str, filter_out: bool = False) -> None: + self.name = name + self.filter_out = filter_out + + @property + def fullrepr(self): + return '%s(%r, %r)' % (type(self).__name__, self.name, self.filter_out) + + def renamed(self, f): + return type(self)(f(self.name), self.filter_out) + + +class NonTerminal(Symbol): + __serialize_fields__ = 'name', + + is_term: ClassVar[bool] = False + + def serialize(self, memo=None) -> Dict[str, Any]: + ## + + ## + + return {'name': str(self.name), '__type__': 'NonTerminal'} + + +class RuleOptions(Serialize): + __serialize_fields__ = 'keep_all_tokens', 'expand1', 'priority', 'template_source', 'empty_indices' + + keep_all_tokens: bool + expand1: bool + priority: Optional[int] + template_source: Optional[str] + empty_indices: Tuple[bool, ...] + + def __init__(self, keep_all_tokens: bool=False, expand1: bool=False, priority: Optional[int]=None, template_source: Optional[str]=None, empty_indices: Tuple[bool, ...]=()) -> None: + self.keep_all_tokens = keep_all_tokens + self.expand1 = expand1 + self.priority = priority + self.template_source = template_source + self.empty_indices = empty_indices + + def __repr__(self): + return 'RuleOptions(%r, %r, %r, %r)' % ( + self.keep_all_tokens, + self.expand1, + self.priority, + self.template_source + ) + + +class Rule(Serialize): + #-- + __slots__ = ('origin', 'expansion', 'alias', 'options', 'order', '_hash') + + __serialize_fields__ = 'origin', 'expansion', 'order', 'alias', 'options' + __serialize_namespace__ = Terminal, NonTerminal, RuleOptions + + origin: NonTerminal + expansion: Sequence[Symbol] + order: int + alias: Optional[str] + options: RuleOptions + _hash: int + + def __init__(self, origin: NonTerminal, expansion: Sequence[Symbol], + order: int=0, alias: Optional[str]=None, options: Optional[RuleOptions]=None): + self.origin = origin + self.expansion = expansion + self.alias = alias + self.order = order + self.options = options or RuleOptions() + self._hash = hash((self.origin, tuple(self.expansion))) + + def _deserialize(self): + self._hash = hash((self.origin, tuple(self.expansion))) + + def __str__(self): + return '<%s : %s>' % (self.origin.name, ' '.join(x.name for x in self.expansion)) + + def __repr__(self): + return 'Rule(%r, %r, %r, %r)' % (self.origin, self.expansion, self.alias, self.options) + + def __hash__(self): + return self._hash + + def __eq__(self, other): + if not isinstance(other, Rule): + return False + return self.origin == other.origin and self.expansion == other.expansion + + + +from contextlib import suppress +from copy import copy + +try: ## + + has_interegular = bool(interegular) +except NameError: + has_interegular = False + +class Pattern(Serialize, ABC): + #-- + + value: str + flags: Collection[str] + raw: Optional[str] + type: ClassVar[str] + + def __init__(self, value: str, flags: Collection[str] = (), raw: Optional[str] = None) -> None: + self.value = value + self.flags = frozenset(flags) + self.raw = raw + + def __repr__(self): + return repr(self.to_regexp()) + + ## + + def __hash__(self): + return hash((type(self), self.value, self.flags)) + + def __eq__(self, other): + return type(self) == type(other) and self.value == other.value and self.flags == other.flags + + @abstractmethod + def to_regexp(self) -> str: + raise NotImplementedError() + + @property + @abstractmethod + def min_width(self) -> int: + raise NotImplementedError() + + @property + @abstractmethod + def max_width(self) -> int: + raise NotImplementedError() + + def _get_flags(self, value): + for f in self.flags: + value = ('(?%s:%s)' % (f, value)) + return value + + +class PatternStr(Pattern): + __serialize_fields__ = 'value', 'flags', 'raw' + + type: ClassVar[str] = "str" + + def to_regexp(self) -> str: + return self._get_flags(re.escape(self.value)) + + @property + def min_width(self) -> int: + return len(self.value) + + @property + def max_width(self) -> int: + return len(self.value) + + +class PatternRE(Pattern): + __serialize_fields__ = 'value', 'flags', 'raw', '_width' + + type: ClassVar[str] = "re" + + def to_regexp(self) -> str: + return self._get_flags(self.value) + + _width = None + def _get_width(self): + if self._width is None: + self._width = get_regexp_width(self.to_regexp()) + return self._width + + @property + def min_width(self) -> int: + return self._get_width()[0] + + @property + def max_width(self) -> int: + return self._get_width()[1] + + +class TerminalDef(Serialize): + #-- + __serialize_fields__ = 'name', 'pattern', 'priority' + __serialize_namespace__ = PatternStr, PatternRE + + name: str + pattern: Pattern + priority: int + + def __init__(self, name: str, pattern: Pattern, priority: int = TOKEN_DEFAULT_PRIORITY) -> None: + assert isinstance(pattern, Pattern), pattern + self.name = name + self.pattern = pattern + self.priority = priority + + def __repr__(self): + return '%s(%r, %r)' % (type(self).__name__, self.name, self.pattern) + + def user_repr(self) -> str: + if self.name.startswith('__'): ## + + return self.pattern.raw or self.name + else: + return self.name + +_T = TypeVar('_T', bound="Token") + +class Token(str): + #-- + __slots__ = ('type', 'start_pos', 'value', 'line', 'column', 'end_line', 'end_column', 'end_pos') + + __match_args__ = ('type', 'value') + + type: str + start_pos: Optional[int] + value: Any + line: Optional[int] + column: Optional[int] + end_line: Optional[int] + end_column: Optional[int] + end_pos: Optional[int] + + + @overload + def __new__( + cls, + type: str, + value: Any, + start_pos: Optional[int] = None, + line: Optional[int] = None, + column: Optional[int] = None, + end_line: Optional[int] = None, + end_column: Optional[int] = None, + end_pos: Optional[int] = None + ) -> 'Token': + ... + + @overload + def __new__( + cls, + type_: str, + value: Any, + start_pos: Optional[int] = None, + line: Optional[int] = None, + column: Optional[int] = None, + end_line: Optional[int] = None, + end_column: Optional[int] = None, + end_pos: Optional[int] = None + ) -> 'Token': ... + + def __new__(cls, *args, **kwargs): + if "type_" in kwargs: + warnings.warn("`type_` is deprecated use `type` instead", DeprecationWarning) + + if "type" in kwargs: + raise TypeError("Error: using both 'type' and the deprecated 'type_' as arguments.") + kwargs["type"] = kwargs.pop("type_") + + return cls._future_new(*args, **kwargs) + + + @classmethod + def _future_new(cls, type, value, start_pos=None, line=None, column=None, end_line=None, end_column=None, end_pos=None): + inst = super(Token, cls).__new__(cls, value) + + inst.type = type + inst.start_pos = start_pos + inst.value = value + inst.line = line + inst.column = column + inst.end_line = end_line + inst.end_column = end_column + inst.end_pos = end_pos + return inst + + @overload + def update(self, type: Optional[str] = None, value: Optional[Any] = None) -> 'Token': + ... + + @overload + def update(self, type_: Optional[str] = None, value: Optional[Any] = None) -> 'Token': + ... + + def update(self, *args, **kwargs): + if "type_" in kwargs: + warnings.warn("`type_` is deprecated use `type` instead", DeprecationWarning) + + if "type" in kwargs: + raise TypeError("Error: using both 'type' and the deprecated 'type_' as arguments.") + kwargs["type"] = kwargs.pop("type_") + + return self._future_update(*args, **kwargs) + + def _future_update(self, type: Optional[str] = None, value: Optional[Any] = None) -> 'Token': + return Token.new_borrow_pos( + type if type is not None else self.type, + value if value is not None else self.value, + self + ) + + @classmethod + def new_borrow_pos(cls: Type[_T], type_: str, value: Any, borrow_t: 'Token') -> _T: + return cls(type_, value, borrow_t.start_pos, borrow_t.line, borrow_t.column, borrow_t.end_line, borrow_t.end_column, borrow_t.end_pos) + + def __reduce__(self): + return (self.__class__, (self.type, self.value, self.start_pos, self.line, self.column)) + + def __repr__(self): + return 'Token(%r, %r)' % (self.type, self.value) + + def __deepcopy__(self, memo): + return Token(self.type, self.value, self.start_pos, self.line, self.column) + + def __eq__(self, other): + if isinstance(other, Token) and self.type != other.type: + return False + + return str.__eq__(self, other) + + __hash__ = str.__hash__ + + +class LineCounter: + #-- + + __slots__ = 'char_pos', 'line', 'column', 'line_start_pos', 'newline_char' + + def __init__(self, newline_char): + self.newline_char = newline_char + self.char_pos = 0 + self.line = 1 + self.column = 1 + self.line_start_pos = 0 + + def __eq__(self, other): + if not isinstance(other, LineCounter): + return NotImplemented + + return self.char_pos == other.char_pos and self.newline_char == other.newline_char + + def feed(self, token: TextOrSlice, test_newline=True): + #-- + if test_newline: + newlines = token.count(self.newline_char) + if newlines: + self.line += newlines + self.line_start_pos = self.char_pos + token.rindex(self.newline_char) + 1 + + self.char_pos += len(token) + self.column = self.char_pos - self.line_start_pos + 1 + + +class UnlessCallback: + def __init__(self, scanner: 'Scanner'): + self.scanner = scanner + + def __call__(self, t: Token): + res = self.scanner.fullmatch(t.value) + if res is not None: + t.type = res + return t + + +class CallChain: + def __init__(self, callback1, callback2, cond): + self.callback1 = callback1 + self.callback2 = callback2 + self.cond = cond + + def __call__(self, t): + t2 = self.callback1(t) + return self.callback2(t) if self.cond(t2) else t2 + + +def _get_match(re_, regexp, s, flags): + m = re_.match(regexp, s, flags) + if m: + return m.group(0) + +def _create_unless(terminals, g_regex_flags, re_, use_bytes): + tokens_by_type = classify(terminals, lambda t: type(t.pattern)) + assert len(tokens_by_type) <= 2, tokens_by_type.keys() + embedded_strs = set() + callback = {} + for retok in tokens_by_type.get(PatternRE, []): + unless = [] + for strtok in tokens_by_type.get(PatternStr, []): + if strtok.priority != retok.priority: + continue + s = strtok.pattern.value + if s == _get_match(re_, retok.pattern.to_regexp(), s, g_regex_flags): + unless.append(strtok) + if strtok.pattern.flags <= retok.pattern.flags: + embedded_strs.add(strtok) + if unless: + callback[retok.name] = UnlessCallback(Scanner(unless, g_regex_flags, re_, use_bytes=use_bytes)) + + new_terminals = [t for t in terminals if t not in embedded_strs] + return new_terminals, callback + + +class Scanner: + def __init__(self, terminals, g_regex_flags, re_, use_bytes): + self.terminals = terminals + self.g_regex_flags = g_regex_flags + self.re_ = re_ + self.use_bytes = use_bytes + + self.allowed_types = {t.name for t in self.terminals} + + self._mres = self._build_mres(terminals, len(terminals)) + + def _build_mres(self, terminals, max_size): + ## + + ## + + ## + + mres = [] + while terminals: + pattern = u'|'.join(u'(?P<%s>%s)' % (t.name, t.pattern.to_regexp()) for t in terminals[:max_size]) + if self.use_bytes: + pattern = pattern.encode('latin-1') + try: + mre = self.re_.compile(pattern, self.g_regex_flags) + except AssertionError: ## + + return self._build_mres(terminals, max_size // 2) + + mres.append(mre) + terminals = terminals[max_size:] + return mres + + def match(self, text: TextSlice, pos): + for mre in self._mres: + m = mre.match(text.text, pos, text.end) + if m: + return m.group(0), m.lastgroup + + + def fullmatch(self, text: str) -> Optional[str]: + for mre in self._mres: + m = mre.fullmatch(text) + if m: + return m.lastgroup + return None + +def _regexp_has_newline(r: str): + #-- + return '\n' in r or '\\n' in r or '\\s' in r or '[^' in r or ('(?s' in r and '.' in r) + + +class LexerState: + #-- + + __slots__ = 'text', 'line_ctr', 'last_token' + + text: TextSlice + line_ctr: LineCounter + last_token: Optional[Token] + + def __init__(self, text: TextSlice, line_ctr: Optional[LineCounter] = None, last_token: Optional[Token]=None): + if isinstance(text, TextSlice): + if line_ctr is None: + line_ctr = LineCounter(b'\n' if isinstance(text.text, bytes) else '\n') + + if text.start > 0: + ## + + line_ctr.feed(TextSlice(text.text, 0, text.start)) + + if not (text.start <= line_ctr.char_pos <= text.end): + raise ValueError("LineCounter.char_pos is out of bounds") + + self.text = text + self.line_ctr = line_ctr + self.last_token = last_token + + + def __eq__(self, other): + if not isinstance(other, LexerState): + return NotImplemented + + return self.text == other.text and self.line_ctr == other.line_ctr and self.last_token == other.last_token + + def __copy__(self): + return type(self)(self.text, copy(self.line_ctr), self.last_token) + + +class LexerThread: + #-- + + def __init__(self, lexer: 'Lexer', lexer_state: Optional[LexerState]): + self.lexer = lexer + self.state = lexer_state + + @classmethod + def from_text(cls, lexer: 'Lexer', text_or_slice: TextOrSlice) -> 'LexerThread': + text = TextSlice.cast_from(text_or_slice) + return cls(lexer, LexerState(text)) + + @classmethod + def from_custom_input(cls, lexer: 'Lexer', text: Any) -> 'LexerThread': + return cls(lexer, LexerState(text)) + + def lex(self, parser_state): + if self.state is None: + raise TypeError("Cannot lex: No text assigned to lexer state") + return self.lexer.lex(self.state, parser_state) + + def __copy__(self): + return type(self)(self.lexer, copy(self.state)) + + _Token = Token + + +_Callback = Callable[[Token], Token] + +class Lexer(ABC): + #-- + @abstractmethod + def lex(self, lexer_state: LexerState, parser_state: Any) -> Iterator[Token]: + return NotImplemented + + def make_lexer_state(self, text: str): + #-- + return LexerState(TextSlice.cast_from(text)) + + +def _check_regex_collisions(terminal_to_regexp: Dict[TerminalDef, str], comparator, strict_mode, max_collisions_to_show=8): + if not comparator: + comparator = interegular.Comparator.from_regexes(terminal_to_regexp) + + ## + + ## + + max_time = 2 if strict_mode else 0.2 + + ## + + if comparator.count_marked_pairs() >= max_collisions_to_show: + return + for group in classify(terminal_to_regexp, lambda t: t.priority).values(): + for a, b in comparator.check(group, skip_marked=True): + assert a.priority == b.priority + ## + + comparator.mark(a, b) + + ## + + message = f"Collision between Terminals {a.name} and {b.name}. " + try: + example = comparator.get_example_overlap(a, b, max_time).format_multiline() + except ValueError: + ## + + example = "No example could be found fast enough. However, the collision does still exists" + if strict_mode: + raise LexError(f"{message}\n{example}") + logger.warning("%s The lexer will choose between them arbitrarily.\n%s", message, example) + if comparator.count_marked_pairs() >= max_collisions_to_show: + logger.warning("Found 8 regex collisions, will not check for more.") + return + + +class AbstractBasicLexer(Lexer): + terminals_by_name: Dict[str, TerminalDef] + + @abstractmethod + def __init__(self, conf: 'LexerConf', comparator=None) -> None: + ... + + @abstractmethod + def next_token(self, lex_state: LexerState, parser_state: Any = None) -> Token: + ... + + def lex(self, state: LexerState, parser_state: Any) -> Iterator[Token]: + with suppress(EOFError): + while True: + yield self.next_token(state, parser_state) + + +class BasicLexer(AbstractBasicLexer): + terminals: Collection[TerminalDef] + ignore_types: FrozenSet[str] + newline_types: FrozenSet[str] + user_callbacks: Dict[str, _Callback] + callback: Dict[str, _Callback] + re: ModuleType + + def __init__(self, conf: 'LexerConf', comparator=None) -> None: + terminals = list(conf.terminals) + assert all(isinstance(t, TerminalDef) for t in terminals), terminals + + self.re = conf.re_module + + if not conf.skip_validation: + ## + + terminal_to_regexp = {} + for t in terminals: + regexp = t.pattern.to_regexp() + try: + self.re.compile(regexp, conf.g_regex_flags) + except self.re.error: + raise LexError("Cannot compile token %s: %s" % (t.name, t.pattern)) + + if t.pattern.min_width == 0: + raise LexError("Lexer does not allow zero-width terminals. (%s: %s)" % (t.name, t.pattern)) + if t.pattern.type == "re": + terminal_to_regexp[t] = regexp + + if not (set(conf.ignore) <= {t.name for t in terminals}): + raise LexError("Ignore terminals are not defined: %s" % (set(conf.ignore) - {t.name for t in terminals})) + + if has_interegular: + _check_regex_collisions(terminal_to_regexp, comparator, conf.strict) + elif conf.strict: + raise LexError("interegular must be installed for strict mode. Use `pip install 'lark[interegular]'`.") + + ## + + self.newline_types = frozenset(t.name for t in terminals if _regexp_has_newline(t.pattern.to_regexp())) + self.ignore_types = frozenset(conf.ignore) + + terminals.sort(key=lambda x: (-x.priority, -x.pattern.max_width, -len(x.pattern.value), x.name)) + self.terminals = terminals + self.user_callbacks = conf.callbacks + self.g_regex_flags = conf.g_regex_flags + self.use_bytes = conf.use_bytes + self.terminals_by_name = conf.terminals_by_name + + self._scanner: Optional[Scanner] = None + + def _build_scanner(self) -> Scanner: + terminals, self.callback = _create_unless(self.terminals, self.g_regex_flags, self.re, self.use_bytes) + assert all(self.callback.values()) + + for type_, f in self.user_callbacks.items(): + if type_ in self.callback: + ## + + self.callback[type_] = CallChain(self.callback[type_], f, lambda t: t.type == type_) + else: + self.callback[type_] = f + + return Scanner(terminals, self.g_regex_flags, self.re, self.use_bytes) + + @property + def scanner(self) -> Scanner: + if self._scanner is None: + self._scanner = self._build_scanner() + return self._scanner + + def match(self, text, pos): + return self.scanner.match(text, pos) + + def next_token(self, lex_state: LexerState, parser_state: Any = None) -> Token: + line_ctr = lex_state.line_ctr + while line_ctr.char_pos < lex_state.text.end: + res = self.match(lex_state.text, line_ctr.char_pos) + if not res: + allowed = self.scanner.allowed_types - self.ignore_types + if not allowed: + allowed = {""} + raise UnexpectedCharacters(lex_state.text.text, line_ctr.char_pos, line_ctr.line, line_ctr.column, + allowed=allowed, token_history=lex_state.last_token and [lex_state.last_token], + state=parser_state, terminals_by_name=self.terminals_by_name) + + value, type_ = res + + ignored = type_ in self.ignore_types + t = None + if not ignored or type_ in self.callback: + t = Token(type_, value, line_ctr.char_pos, line_ctr.line, line_ctr.column) + line_ctr.feed(value, type_ in self.newline_types) + if t is not None: + t.end_line = line_ctr.line + t.end_column = line_ctr.column + t.end_pos = line_ctr.char_pos + if t.type in self.callback: + t = self.callback[t.type](t) + if not ignored: + if not isinstance(t, Token): + raise LexError("Callbacks must return a token (returned %r)" % t) + lex_state.last_token = t + return t + + ## + + raise EOFError(self) + + +class ContextualLexer(Lexer): + lexers: Dict[int, AbstractBasicLexer] + root_lexer: AbstractBasicLexer + + BasicLexer: Type[AbstractBasicLexer] = BasicLexer + + def __init__(self, conf: 'LexerConf', states: Dict[int, Collection[str]], always_accept: Collection[str]=()) -> None: + terminals = list(conf.terminals) + terminals_by_name = conf.terminals_by_name + + trad_conf = copy(conf) + trad_conf.terminals = terminals + + if has_interegular and not conf.skip_validation: + comparator = interegular.Comparator.from_regexes({t: t.pattern.to_regexp() for t in terminals}) + else: + comparator = None + lexer_by_tokens: Dict[FrozenSet[str], AbstractBasicLexer] = {} + self.lexers = {} + for state, accepts in states.items(): + key = frozenset(accepts) + try: + lexer = lexer_by_tokens[key] + except KeyError: + accepts = set(accepts) | set(conf.ignore) | set(always_accept) + lexer_conf = copy(trad_conf) + lexer_conf.terminals = [terminals_by_name[n] for n in accepts if n in terminals_by_name] + lexer = self.BasicLexer(lexer_conf, comparator) + lexer_by_tokens[key] = lexer + + self.lexers[state] = lexer + + assert trad_conf.terminals is terminals + trad_conf.skip_validation = True ## + + self.root_lexer = self.BasicLexer(trad_conf, comparator) + + def lex(self, lexer_state: LexerState, parser_state: 'ParserState') -> Iterator[Token]: + try: + while True: + lexer = self.lexers[parser_state.position] + yield lexer.next_token(lexer_state, parser_state) + except EOFError: + pass + except UnexpectedCharacters as e: + ## + + ## + + try: + last_token = lexer_state.last_token ## + + token = self.root_lexer.next_token(lexer_state, parser_state) + raise UnexpectedToken(token, e.allowed, state=parser_state, token_history=[last_token], terminals_by_name=self.root_lexer.terminals_by_name) + except UnexpectedCharacters: + raise e ## + + + + +_ParserArgType: 'TypeAlias' = 'Literal["earley", "lalr", "cyk", "auto"]' +_LexerArgType: 'TypeAlias' = 'Union[Literal["auto", "basic", "contextual", "dynamic", "dynamic_complete"], Type[Lexer]]' +_LexerCallback = Callable[[Token], Token] +ParserCallbacks = Dict[str, Callable] + +class LexerConf(Serialize): + __serialize_fields__ = 'terminals', 'ignore', 'g_regex_flags', 'use_bytes', 'lexer_type' + __serialize_namespace__ = TerminalDef, + + terminals: Collection[TerminalDef] + re_module: ModuleType + ignore: Collection[str] + postlex: 'Optional[PostLex]' + callbacks: Dict[str, _LexerCallback] + g_regex_flags: int + skip_validation: bool + use_bytes: bool + lexer_type: Optional[_LexerArgType] + strict: bool + + def __init__(self, terminals: Collection[TerminalDef], re_module: ModuleType, ignore: Collection[str]=(), postlex: 'Optional[PostLex]'=None, + callbacks: Optional[Dict[str, _LexerCallback]]=None, g_regex_flags: int=0, skip_validation: bool=False, use_bytes: bool=False, strict: bool=False): + self.terminals = terminals + self.terminals_by_name = {t.name: t for t in self.terminals} + assert len(self.terminals) == len(self.terminals_by_name) + self.ignore = ignore + self.postlex = postlex + self.callbacks = callbacks or {} + self.g_regex_flags = g_regex_flags + self.re_module = re_module + self.skip_validation = skip_validation + self.use_bytes = use_bytes + self.strict = strict + self.lexer_type = None + + def _deserialize(self): + self.terminals_by_name = {t.name: t for t in self.terminals} + + def __deepcopy__(self, memo=None): + return type(self)( + deepcopy(self.terminals, memo), + self.re_module, + deepcopy(self.ignore, memo), + deepcopy(self.postlex, memo), + deepcopy(self.callbacks, memo), + deepcopy(self.g_regex_flags, memo), + deepcopy(self.skip_validation, memo), + deepcopy(self.use_bytes, memo), + ) + +class ParserConf(Serialize): + __serialize_fields__ = 'rules', 'start', 'parser_type' + + rules: List['Rule'] + callbacks: ParserCallbacks + start: List[str] + parser_type: _ParserArgType + + def __init__(self, rules: List['Rule'], callbacks: ParserCallbacks, start: List[str]): + assert isinstance(start, list) + self.rules = rules + self.callbacks = callbacks + self.start = start + + +from functools import partial, wraps +from itertools import product + + +class ExpandSingleChild: + def __init__(self, node_builder): + self.node_builder = node_builder + + def __call__(self, children): + if len(children) == 1: + return children[0] + else: + return self.node_builder(children) + + + +class PropagatePositions: + def __init__(self, node_builder, node_filter=None): + self.node_builder = node_builder + self.node_filter = node_filter + + def __call__(self, children): + res = self.node_builder(children) + + if isinstance(res, Tree): + ## + + ## + + ## + + ## + + + res_meta = res.meta + + first_meta = self._pp_get_meta(children) + if first_meta is not None: + if not hasattr(res_meta, 'line'): + ## + + res_meta.line = getattr(first_meta, 'container_line', first_meta.line) + res_meta.column = getattr(first_meta, 'container_column', first_meta.column) + res_meta.start_pos = getattr(first_meta, 'container_start_pos', first_meta.start_pos) + res_meta.empty = False + + res_meta.container_line = getattr(first_meta, 'container_line', first_meta.line) + res_meta.container_column = getattr(first_meta, 'container_column', first_meta.column) + res_meta.container_start_pos = getattr(first_meta, 'container_start_pos', first_meta.start_pos) + + last_meta = self._pp_get_meta(reversed(children)) + if last_meta is not None: + if not hasattr(res_meta, 'end_line'): + res_meta.end_line = getattr(last_meta, 'container_end_line', last_meta.end_line) + res_meta.end_column = getattr(last_meta, 'container_end_column', last_meta.end_column) + res_meta.end_pos = getattr(last_meta, 'container_end_pos', last_meta.end_pos) + res_meta.empty = False + + res_meta.container_end_line = getattr(last_meta, 'container_end_line', last_meta.end_line) + res_meta.container_end_column = getattr(last_meta, 'container_end_column', last_meta.end_column) + res_meta.container_end_pos = getattr(last_meta, 'container_end_pos', last_meta.end_pos) + + return res + + def _pp_get_meta(self, children): + for c in children: + if self.node_filter is not None and not self.node_filter(c): + continue + if isinstance(c, Tree): + if not c.meta.empty: + return c.meta + elif isinstance(c, Token): + return c + elif hasattr(c, '__lark_meta__'): + return c.__lark_meta__() + +def make_propagate_positions(option): + if callable(option): + return partial(PropagatePositions, node_filter=option) + elif option is True: + return PropagatePositions + elif option is False: + return None + + raise ConfigurationError('Invalid option for propagate_positions: %r' % option) + + +class ChildFilter: + def __init__(self, to_include, append_none, node_builder): + self.node_builder = node_builder + self.to_include = to_include + self.append_none = append_none + + def __call__(self, children): + filtered = [] + + for i, to_expand, add_none in self.to_include: + if add_none: + filtered += [None] * add_none + if to_expand: + filtered += children[i].children + else: + filtered.append(children[i]) + + if self.append_none: + filtered += [None] * self.append_none + + return self.node_builder(filtered) + + +class ChildFilterLALR(ChildFilter): + #-- + + def __call__(self, children): + filtered = [] + for i, to_expand, add_none in self.to_include: + if add_none: + filtered += [None] * add_none + if to_expand: + if filtered: + filtered += children[i].children + else: ## + + filtered = children[i].children + else: + filtered.append(children[i]) + + if self.append_none: + filtered += [None] * self.append_none + + return self.node_builder(filtered) + + +class ChildFilterLALR_NoPlaceholders(ChildFilter): + #-- + def __init__(self, to_include, node_builder): + self.node_builder = node_builder + self.to_include = to_include + + def __call__(self, children): + filtered = [] + for i, to_expand in self.to_include: + if to_expand: + if filtered: + filtered += children[i].children + else: ## + + filtered = children[i].children + else: + filtered.append(children[i]) + return self.node_builder(filtered) + + +def _should_expand(sym): + return not sym.is_term and sym.name.startswith('_') + + +def maybe_create_child_filter(expansion, keep_all_tokens, ambiguous, _empty_indices: List[bool]): + ## + + if _empty_indices: + assert _empty_indices.count(False) == len(expansion) + s = ''.join(str(int(b)) for b in _empty_indices) + empty_indices = [len(ones) for ones in s.split('0')] + assert len(empty_indices) == len(expansion)+1, (empty_indices, len(expansion)) + else: + empty_indices = [0] * (len(expansion)+1) + + to_include = [] + nones_to_add = 0 + for i, sym in enumerate(expansion): + nones_to_add += empty_indices[i] + if keep_all_tokens or not (sym.is_term and sym.filter_out): + to_include.append((i, _should_expand(sym), nones_to_add)) + nones_to_add = 0 + + nones_to_add += empty_indices[len(expansion)] + + if _empty_indices or len(to_include) < len(expansion) or any(to_expand for i, to_expand,_ in to_include): + if _empty_indices or ambiguous: + return partial(ChildFilter if ambiguous else ChildFilterLALR, to_include, nones_to_add) + else: + ## + + return partial(ChildFilterLALR_NoPlaceholders, [(i, x) for i,x,_ in to_include]) + + +class AmbiguousExpander: + #-- + def __init__(self, to_expand, tree_class, node_builder): + self.node_builder = node_builder + self.tree_class = tree_class + self.to_expand = to_expand + + def __call__(self, children): + def _is_ambig_tree(t): + return hasattr(t, 'data') and t.data == '_ambig' + + ## + + ## + + ## + + ## + + ambiguous = [] + for i, child in enumerate(children): + if _is_ambig_tree(child): + if i in self.to_expand: + ambiguous.append(i) + + child.expand_kids_by_data('_ambig') + + if not ambiguous: + return self.node_builder(children) + + expand = [child.children if i in ambiguous else (child,) for i, child in enumerate(children)] + return self.tree_class('_ambig', [self.node_builder(list(f)) for f in product(*expand)]) + + +def maybe_create_ambiguous_expander(tree_class, expansion, keep_all_tokens): + to_expand = [i for i, sym in enumerate(expansion) + if keep_all_tokens or ((not (sym.is_term and sym.filter_out)) and _should_expand(sym))] + if to_expand: + return partial(AmbiguousExpander, to_expand, tree_class) + + +class AmbiguousIntermediateExpander: + #-- + + def __init__(self, tree_class, node_builder): + self.node_builder = node_builder + self.tree_class = tree_class + + def __call__(self, children): + def _is_iambig_tree(child): + return hasattr(child, 'data') and child.data == '_iambig' + + def _collapse_iambig(children): + #-- + + ## + + ## + + if children and _is_iambig_tree(children[0]): + iambig_node = children[0] + result = [] + for grandchild in iambig_node.children: + collapsed = _collapse_iambig(grandchild.children) + if collapsed: + for child in collapsed: + child.children += children[1:] + result += collapsed + else: + new_tree = self.tree_class('_inter', grandchild.children + children[1:]) + result.append(new_tree) + return result + + collapsed = _collapse_iambig(children) + if collapsed: + processed_nodes = [self.node_builder(c.children) for c in collapsed] + return self.tree_class('_ambig', processed_nodes) + + return self.node_builder(children) + + + +def inplace_transformer(func): + @wraps(func) + def f(children): + ## + + tree = Tree(func.__name__, children) + return func(tree) + return f + + +def apply_visit_wrapper(func, name, wrapper): + if wrapper is _vargs_meta or wrapper is _vargs_meta_inline: + raise NotImplementedError("Meta args not supported for internal transformer; use YourTransformer().transform(parser.parse()) instead") + + @wraps(func) + def f(children): + return wrapper(func, name, children, None) + return f + + +class ParseTreeBuilder: + def __init__(self, rules, tree_class, propagate_positions=False, ambiguous=False, maybe_placeholders=False): + self.tree_class = tree_class + self.propagate_positions = propagate_positions + self.ambiguous = ambiguous + self.maybe_placeholders = maybe_placeholders + + self.rule_builders = list(self._init_builders(rules)) + + def _init_builders(self, rules): + propagate_positions = make_propagate_positions(self.propagate_positions) + + for rule in rules: + options = rule.options + keep_all_tokens = options.keep_all_tokens + expand_single_child = options.expand1 + + wrapper_chain = list(filter(None, [ + (expand_single_child and not rule.alias) and ExpandSingleChild, + maybe_create_child_filter(rule.expansion, keep_all_tokens, self.ambiguous, options.empty_indices if self.maybe_placeholders else None), + propagate_positions, + self.ambiguous and maybe_create_ambiguous_expander(self.tree_class, rule.expansion, keep_all_tokens), + self.ambiguous and partial(AmbiguousIntermediateExpander, self.tree_class) + ])) + + yield rule, wrapper_chain + + def create_callback(self, transformer=None): + callbacks = {} + + default_handler = getattr(transformer, '__default__', None) + if default_handler: + def default_callback(data, children): + return default_handler(data, children, None) + else: + default_callback = self.tree_class + + for rule, wrapper_chain in self.rule_builders: + + user_callback_name = rule.alias or rule.options.template_source or rule.origin.name + try: + f = getattr(transformer, user_callback_name) + wrapper = getattr(f, 'visit_wrapper', None) + if wrapper is not None: + f = apply_visit_wrapper(f, user_callback_name, wrapper) + elif isinstance(transformer, Transformer_InPlace): + f = inplace_transformer(f) + except AttributeError: + f = partial(default_callback, user_callback_name) + + for w in wrapper_chain: + f = w(f) + + if rule in callbacks: + raise GrammarError("Rule '%s' already exists" % (rule,)) + + callbacks[rule] = f + + return callbacks + + + +class Action: + def __init__(self, name): + self.name = name + def __str__(self): + return self.name + def __repr__(self): + return str(self) + +Shift = Action('Shift') +Reduce = Action('Reduce') + +StateT = TypeVar("StateT") + +class ParseTableBase(Generic[StateT]): + states: Dict[StateT, Dict[str, Tuple]] + start_states: Dict[str, StateT] + end_states: Dict[str, StateT] + + def __init__(self, states, start_states, end_states): + self.states = states + self.start_states = start_states + self.end_states = end_states + + def serialize(self, memo): + tokens = Enumerator() + + states = { + state: {tokens.get(token): ((1, arg.serialize(memo)) if action is Reduce else (0, arg)) + for token, (action, arg) in actions.items()} + for state, actions in self.states.items() + } + + return { + 'tokens': tokens.reversed(), + 'states': states, + 'start_states': self.start_states, + 'end_states': self.end_states, + } + + @classmethod + def deserialize(cls, data, memo): + tokens = data['tokens'] + states = { + state: {tokens[token]: ((Reduce, Rule.deserialize(arg, memo)) if action==1 else (Shift, arg)) + for token, (action, arg) in actions.items()} + for state, actions in data['states'].items() + } + return cls(states, data['start_states'], data['end_states']) + +class ParseTable(ParseTableBase['State']): + #-- + pass + + +class IntParseTable(ParseTableBase[int]): + #-- + + @classmethod + def from_ParseTable(cls, parse_table: ParseTable): + enum = list(parse_table.states) + state_to_idx: Dict['State', int] = {s:i for i,s in enumerate(enum)} + int_states = {} + + for s, la in parse_table.states.items(): + la = {k:(v[0], state_to_idx[v[1]]) if v[0] is Shift else v + for k,v in la.items()} + int_states[ state_to_idx[s] ] = la + + + start_states = {start:state_to_idx[s] for start, s in parse_table.start_states.items()} + end_states = {start:state_to_idx[s] for start, s in parse_table.end_states.items()} + return cls(int_states, start_states, end_states) + + + +class ParseConf(Generic[StateT]): + __slots__ = 'parse_table', 'callbacks', 'start', 'start_state', 'end_state', 'states' + + parse_table: ParseTableBase[StateT] + callbacks: ParserCallbacks + start: str + + start_state: StateT + end_state: StateT + states: Dict[StateT, Dict[str, tuple]] + + def __init__(self, parse_table: ParseTableBase[StateT], callbacks: ParserCallbacks, start: str): + self.parse_table = parse_table + + self.start_state = self.parse_table.start_states[start] + self.end_state = self.parse_table.end_states[start] + self.states = self.parse_table.states + + self.callbacks = callbacks + self.start = start + +class ParserState(Generic[StateT]): + __slots__ = 'parse_conf', 'lexer', 'state_stack', 'value_stack' + + parse_conf: ParseConf[StateT] + lexer: LexerThread + state_stack: List[StateT] + value_stack: list + + def __init__(self, parse_conf: ParseConf[StateT], lexer: LexerThread, state_stack=None, value_stack=None): + self.parse_conf = parse_conf + self.lexer = lexer + self.state_stack = state_stack or [self.parse_conf.start_state] + self.value_stack = value_stack or [] + + @property + def position(self) -> StateT: + return self.state_stack[-1] + + ## + + def __eq__(self, other) -> bool: + if not isinstance(other, ParserState): + return NotImplemented + return len(self.state_stack) == len(other.state_stack) and self.position == other.position + + def __copy__(self): + return self.copy() + + def copy(self, deepcopy_values=True) -> 'ParserState[StateT]': + return type(self)( + self.parse_conf, + self.lexer, ## + + copy(self.state_stack), + deepcopy(self.value_stack) if deepcopy_values else copy(self.value_stack), + ) + + def feed_token(self, token: Token, is_end=False) -> Any: + state_stack = self.state_stack + value_stack = self.value_stack + states = self.parse_conf.states + end_state = self.parse_conf.end_state + callbacks = self.parse_conf.callbacks + + while True: + state = state_stack[-1] + try: + action, arg = states[state][token.type] + except KeyError: + expected = {s for s in states[state].keys() if s.isupper()} + raise UnexpectedToken(token, expected, state=self, interactive_parser=None) + + assert arg != end_state + + if action is Shift: + ## + + assert not is_end + state_stack.append(arg) + value_stack.append(token if token.type not in callbacks else callbacks[token.type](token)) + return + else: + ## + + rule = arg + size = len(rule.expansion) + if size: + s = value_stack[-size:] + del state_stack[-size:] + del value_stack[-size:] + else: + s = [] + + value = callbacks[rule](s) if callbacks else s + + _action, new_state = states[state_stack[-1]][rule.origin.name] + assert _action is Shift + state_stack.append(new_state) + value_stack.append(value) + + if is_end and state_stack[-1] == end_state: + return value_stack[-1] + + +class LALR_Parser(Serialize): + def __init__(self, parser_conf: ParserConf, debug: bool=False, strict: bool=False): + analysis = LALR_Analyzer(parser_conf, debug=debug, strict=strict) + analysis.compute_lalr() + callbacks = parser_conf.callbacks + + self._parse_table = analysis.parse_table + self.parser_conf = parser_conf + self.parser = _Parser(analysis.parse_table, callbacks, debug) + + @classmethod + def deserialize(cls, data, memo, callbacks, debug=False): + inst = cls.__new__(cls) + inst._parse_table = IntParseTable.deserialize(data, memo) + inst.parser = _Parser(inst._parse_table, callbacks, debug) + return inst + + def serialize(self, memo: Any = None) -> Dict[str, Any]: + return self._parse_table.serialize(memo) + + def parse_interactive(self, lexer: LexerThread, start: str): + return self.parser.parse(lexer, start, start_interactive=True) + + def parse(self, lexer, start, on_error=None): + try: + return self.parser.parse(lexer, start) + except UnexpectedInput as e: + if on_error is None: + raise + + while True: + if isinstance(e, UnexpectedCharacters): + s = e.interactive_parser.lexer_thread.state + p = s.line_ctr.char_pos + + if not on_error(e): + raise e + + if isinstance(e, UnexpectedCharacters): + ## + + if p == s.line_ctr.char_pos: + s.line_ctr.feed(s.text.text[p:p+1]) + + try: + return e.interactive_parser.resume_parse() + except UnexpectedToken as e2: + if (isinstance(e, UnexpectedToken) + and e.token.type == e2.token.type == '$END' + and e.interactive_parser == e2.interactive_parser): + ## + + raise e2 + e = e2 + except UnexpectedCharacters as e2: + e = e2 + + +class _Parser: + parse_table: ParseTableBase + callbacks: ParserCallbacks + debug: bool + + def __init__(self, parse_table: ParseTableBase, callbacks: ParserCallbacks, debug: bool=False): + self.parse_table = parse_table + self.callbacks = callbacks + self.debug = debug + + def parse(self, lexer: LexerThread, start: str, value_stack=None, state_stack=None, start_interactive=False): + parse_conf = ParseConf(self.parse_table, self.callbacks, start) + parser_state = ParserState(parse_conf, lexer, state_stack, value_stack) + if start_interactive: + return InteractiveParser(self, parser_state, parser_state.lexer) + return self.parse_from_state(parser_state) + + + def parse_from_state(self, state: ParserState, last_token: Optional[Token]=None): + #-- + try: + token = last_token + for token in state.lexer.lex(state): + assert token is not None + state.feed_token(token) + + end_token = Token.new_borrow_pos('$END', '', token) if token else Token('$END', '', 0, 1, 1) + return state.feed_token(end_token, True) + except UnexpectedInput as e: + try: + e.interactive_parser = InteractiveParser(self, state, state.lexer) + except NameError: + pass + raise e + except Exception as e: + if self.debug: + print("") + print("STATE STACK DUMP") + print("----------------") + for i, s in enumerate(state.state_stack): + print('%d)' % i , s) + print("") + + raise + + +class InteractiveParser: + #-- + def __init__(self, parser, parser_state: ParserState, lexer_thread: LexerThread): + self.parser = parser + self.parser_state = parser_state + self.lexer_thread = lexer_thread + self.result = None + + @property + def lexer_state(self) -> LexerThread: + warnings.warn("lexer_state will be removed in subsequent releases. Use lexer_thread instead.", DeprecationWarning) + return self.lexer_thread + + def feed_token(self, token: Token): + #-- + return self.parser_state.feed_token(token, token.type == '$END') + + def iter_parse(self) -> Iterator[Token]: + #-- + for token in self.lexer_thread.lex(self.parser_state): + yield token + self.result = self.feed_token(token) + + def exhaust_lexer(self) -> List[Token]: + #-- + return list(self.iter_parse()) + + + def feed_eof(self, last_token=None): + #-- + eof = Token.new_borrow_pos('$END', '', last_token) if last_token is not None else self.lexer_thread._Token('$END', '', 0, 1, 1) + return self.feed_token(eof) + + + def __copy__(self): + #-- + return self.copy() + + def copy(self, deepcopy_values=True): + return type(self)( + self.parser, + self.parser_state.copy(deepcopy_values=deepcopy_values), + copy(self.lexer_thread), + ) + + def __eq__(self, other): + if not isinstance(other, InteractiveParser): + return False + + return self.parser_state == other.parser_state and self.lexer_thread == other.lexer_thread + + def as_immutable(self): + #-- + p = copy(self) + return ImmutableInteractiveParser(p.parser, p.parser_state, p.lexer_thread) + + def pretty(self): + #-- + out = ["Parser choices:"] + for k, v in self.choices().items(): + out.append('\t- %s -> %r' % (k, v)) + out.append('stack size: %s' % len(self.parser_state.state_stack)) + return '\n'.join(out) + + def choices(self): + #-- + return self.parser_state.parse_conf.parse_table.states[self.parser_state.position] + + def accepts(self): + #-- + accepts = set() + conf_no_callbacks = copy(self.parser_state.parse_conf) + ## + + ## + + conf_no_callbacks.callbacks = {} + for t in self.choices(): + if t.isupper(): ## + + new_cursor = self.copy(deepcopy_values=False) + new_cursor.parser_state.parse_conf = conf_no_callbacks + try: + new_cursor.feed_token(self.lexer_thread._Token(t, '')) + except UnexpectedToken: + pass + else: + accepts.add(t) + return accepts + + def resume_parse(self): + #-- + return self.parser.parse_from_state(self.parser_state, last_token=self.lexer_thread.state.last_token) + + + +class ImmutableInteractiveParser(InteractiveParser): + #-- + + result = None + + def __hash__(self): + return hash((self.parser_state, self.lexer_thread)) + + def feed_token(self, token): + c = copy(self) + c.result = InteractiveParser.feed_token(c, token) + return c + + def exhaust_lexer(self): + #-- + cursor = self.as_mutable() + cursor.exhaust_lexer() + return cursor.as_immutable() + + def as_mutable(self): + #-- + p = copy(self) + return InteractiveParser(p.parser, p.parser_state, p.lexer_thread) + + + +def _wrap_lexer(lexer_class): + future_interface = getattr(lexer_class, '__future_interface__', 0) + if future_interface == 2: + return lexer_class + elif future_interface == 1: + class CustomLexerWrapper1(Lexer): + def __init__(self, lexer_conf): + self.lexer = lexer_class(lexer_conf) + def lex(self, lexer_state, parser_state): + if isinstance(lexer_state.text, TextSlice) and not lexer_state.text.is_complete_text(): + raise TypeError("Interface=1 Custom Lexer don't support TextSlice") + lexer_state.text = lexer_state.text + return self.lexer.lex(lexer_state, parser_state) + return CustomLexerWrapper1 + elif future_interface == 0: + class CustomLexerWrapper0(Lexer): + def __init__(self, lexer_conf): + self.lexer = lexer_class(lexer_conf) + + def lex(self, lexer_state, parser_state): + if isinstance(lexer_state.text, TextSlice): + if not lexer_state.text.is_complete_text(): + raise TypeError("Interface=0 Custom Lexer don't support TextSlice") + return self.lexer.lex(lexer_state.text.text) + return self.lexer.lex(lexer_state.text) + return CustomLexerWrapper0 + else: + raise ValueError(f"Unknown __future_interface__ value {future_interface}, integer 0-2 expected") + + +def _deserialize_parsing_frontend(data, memo, lexer_conf, callbacks, options): + parser_conf = ParserConf.deserialize(data['parser_conf'], memo) + cls = (options and options._plugins.get('LALR_Parser')) or LALR_Parser + parser = cls.deserialize(data['parser'], memo, callbacks, options.debug) + parser_conf.callbacks = callbacks + return ParsingFrontend(lexer_conf, parser_conf, options, parser=parser) + + +_parser_creators: 'Dict[str, Callable[[LexerConf, Any, Any], Any]]' = {} + + +class ParsingFrontend(Serialize): + __serialize_fields__ = 'lexer_conf', 'parser_conf', 'parser' + + lexer_conf: LexerConf + parser_conf: ParserConf + options: Any + + def __init__(self, lexer_conf: LexerConf, parser_conf: ParserConf, options, parser=None): + self.parser_conf = parser_conf + self.lexer_conf = lexer_conf + self.options = options + + ## + + if parser: ## + + self.parser = parser + else: + create_parser = _parser_creators.get(parser_conf.parser_type) + assert create_parser is not None, "{} is not supported in standalone mode".format( + parser_conf.parser_type + ) + self.parser = create_parser(lexer_conf, parser_conf, options) + + ## + + lexer_type = lexer_conf.lexer_type + self.skip_lexer = False + if lexer_type in ('dynamic', 'dynamic_complete'): + assert lexer_conf.postlex is None + self.skip_lexer = True + return + + if isinstance(lexer_type, type): + assert issubclass(lexer_type, Lexer) + self.lexer = _wrap_lexer(lexer_type)(lexer_conf) + elif isinstance(lexer_type, str): + create_lexer = { + 'basic': create_basic_lexer, + 'contextual': create_contextual_lexer, + }[lexer_type] + self.lexer = create_lexer(lexer_conf, self.parser, lexer_conf.postlex, options) + else: + raise TypeError("Bad value for lexer_type: {lexer_type}") + + if lexer_conf.postlex: + self.lexer = PostLexConnector(self.lexer, lexer_conf.postlex) + + def _verify_start(self, start=None): + if start is None: + start_decls = self.parser_conf.start + if len(start_decls) > 1: + raise ConfigurationError("Lark initialized with more than 1 possible start rule. Must specify which start rule to parse", start_decls) + start ,= start_decls + elif start not in self.parser_conf.start: + raise ConfigurationError("Unknown start rule %s. Must be one of %r" % (start, self.parser_conf.start)) + return start + + def _make_lexer_thread(self, text: Optional[LarkInput]) -> Union[LarkInput, LexerThread, None]: + cls = (self.options and self.options._plugins.get('LexerThread')) or LexerThread + if self.skip_lexer: + return text + if text is None: + return cls(self.lexer, None) + if isinstance(text, (str, bytes, TextSlice)): + return cls.from_text(self.lexer, text) + return cls.from_custom_input(self.lexer, text) + + def parse(self, text: Optional[LarkInput], start=None, on_error=None): + if self.lexer_conf.lexer_type in ("dynamic", "dynamic_complete"): + if isinstance(text, TextSlice) and not text.is_complete_text(): + raise TypeError(f"Lexer {self.lexer_conf.lexer_type} does not support text slices.") + + chosen_start = self._verify_start(start) + kw = {} if on_error is None else {'on_error': on_error} + stream = self._make_lexer_thread(text) + return self.parser.parse(stream, chosen_start, **kw) + + def parse_interactive(self, text: Optional[TextOrSlice]=None, start=None): + ## + + ## + + chosen_start = self._verify_start(start) + if self.parser_conf.parser_type != 'lalr': + raise ConfigurationError("parse_interactive() currently only works with parser='lalr' ") + stream = self._make_lexer_thread(text) + return self.parser.parse_interactive(stream, chosen_start) + + +def _validate_frontend_args(parser, lexer) -> None: + assert_config(parser, ('lalr', 'earley', 'cyk')) + if not isinstance(lexer, type): ## + + expected = { + 'lalr': ('basic', 'contextual'), + 'earley': ('basic', 'dynamic', 'dynamic_complete'), + 'cyk': ('basic', ), + }[parser] + assert_config(lexer, expected, 'Parser %r does not support lexer %%r, expected one of %%s' % parser) + + +def _get_lexer_callbacks(transformer, terminals): + result = {} + for terminal in terminals: + callback = getattr(transformer, terminal.name, None) + if callback is not None: + result[terminal.name] = callback + return result + +class PostLexConnector: + def __init__(self, lexer, postlexer): + self.lexer = lexer + self.postlexer = postlexer + + def lex(self, lexer_state, parser_state): + i = self.lexer.lex(lexer_state, parser_state) + return self.postlexer.process(i) + + + +def create_basic_lexer(lexer_conf, parser, postlex, options) -> BasicLexer: + cls = (options and options._plugins.get('BasicLexer')) or BasicLexer + return cls(lexer_conf) + +def create_contextual_lexer(lexer_conf: LexerConf, parser, postlex, options) -> ContextualLexer: + cls = (options and options._plugins.get('ContextualLexer')) or ContextualLexer + parse_table: ParseTableBase[int] = parser._parse_table + states: Dict[int, Collection[str]] = {idx:list(t.keys()) for idx, t in parse_table.states.items()} + always_accept: Collection[str] = postlex.always_accept if postlex else () + return cls(lexer_conf, states, always_accept=always_accept) + +def create_lalr_parser(lexer_conf: LexerConf, parser_conf: ParserConf, options=None) -> LALR_Parser: + debug = options.debug if options else False + strict = options.strict if options else False + cls = (options and options._plugins.get('LALR_Parser')) or LALR_Parser + return cls(parser_conf, debug=debug, strict=strict) + +_parser_creators['lalr'] = create_lalr_parser + + + + +class PostLex(ABC): + @abstractmethod + def process(self, stream: Iterator[Token]) -> Iterator[Token]: + return stream + + always_accept: Iterable[str] = () + +class LarkOptions(Serialize): + #-- + + start: List[str] + debug: bool + strict: bool + transformer: 'Optional[Transformer]' + propagate_positions: Union[bool, str] + maybe_placeholders: bool + cache: Union[bool, str] + cache_grammar: bool + regex: bool + g_regex_flags: int + keep_all_tokens: bool + tree_class: Optional[Callable[[str, List], Any]] + parser: _ParserArgType + lexer: _LexerArgType + ambiguity: 'Literal["auto", "resolve", "explicit", "forest"]' + postlex: Optional[PostLex] + priority: 'Optional[Literal["auto", "normal", "invert"]]' + lexer_callbacks: Dict[str, Callable[[Token], Token]] + use_bytes: bool + ordered_sets: bool + edit_terminals: Optional[Callable[[TerminalDef], TerminalDef]] + import_paths: 'List[Union[str, Callable[[Union[None, str, PackageResource], str], Tuple[str, str]]]]' + source_path: Optional[str] + + OPTIONS_DOC = r""" + **=== General Options ===** + + start + The start symbol. Either a string, or a list of strings for multiple possible starts (Default: "start") + debug + Display debug information and extra warnings. Use only when debugging (Default: ``False``) + When used with Earley, it generates a forest graph as "sppf.png", if 'dot' is installed. + strict + Throw an exception on any potential ambiguity, including shift/reduce conflicts, and regex collisions. + transformer + Applies the transformer to every parse tree (equivalent to applying it after the parse, but faster) + propagate_positions + Propagates positional attributes into the 'meta' attribute of all tree branches. + Sets attributes: (line, column, end_line, end_column, start_pos, end_pos, + container_line, container_column, container_end_line, container_end_column) + Accepts ``False``, ``True``, or a callable, which will filter which nodes to ignore when propagating. + maybe_placeholders + When ``True``, the ``[]`` operator returns ``None`` when not matched. + When ``False``, ``[]`` behaves like the ``?`` operator, and returns no value at all. + (default= ``True``) + cache + Cache the results of the Lark grammar analysis, for x2 to x3 faster loading. LALR only for now. + + - When ``False``, does nothing (default) + - When ``True``, caches to a temporary file in the local directory + - When given a string, caches to the path pointed by the string + cache_grammar + For use with ``cache`` option. When ``True``, the unanalyzed grammar is also included in the cache. + Useful for classes that require the ``Lark.grammar`` to be present (e.g. Reconstructor). + (default= ``False``) + regex + When True, uses the ``regex`` module instead of the stdlib ``re``. + g_regex_flags + Flags that are applied to all terminals (both regex and strings) + keep_all_tokens + Prevent the tree builder from automagically removing "punctuation" tokens (Default: ``False``) + tree_class + Lark will produce trees comprised of instances of this class instead of the default ``lark.Tree``. + + **=== Algorithm Options ===** + + parser + Decides which parser engine to use. Accepts "earley" or "lalr". (Default: "earley"). + (there is also a "cyk" option for legacy) + lexer + Decides whether or not to use a lexer stage + + - "auto" (default): Choose for me based on the parser + - "basic": Use a basic lexer + - "contextual": Stronger lexer (only works with parser="lalr") + - "dynamic": Flexible and powerful (only with parser="earley") + - "dynamic_complete": Same as dynamic, but tries *every* variation of tokenizing possible. + ambiguity + Decides how to handle ambiguity in the parse. Only relevant if parser="earley" + + - "resolve": The parser will automatically choose the simplest derivation + (it chooses consistently: greedy for tokens, non-greedy for rules) + - "explicit": The parser will return all derivations wrapped in "_ambig" tree nodes (i.e. a forest). + - "forest": The parser will return the root of the shared packed parse forest. + + **=== Misc. / Domain Specific Options ===** + + postlex + Lexer post-processing (Default: ``None``) Only works with the basic and contextual lexers. + priority + How priorities should be evaluated - "auto", ``None``, "normal", "invert" (Default: "auto") + lexer_callbacks + Dictionary of callbacks for the lexer. May alter tokens during lexing. Use with caution. + use_bytes + Accept an input of type ``bytes`` instead of ``str``. + ordered_sets + Should Earley use ordered-sets to achieve stable output (~10% slower than regular sets. Default: True) + edit_terminals + A callback for editing the terminals before parse. + import_paths + A List of either paths or loader functions to specify from where grammars are imported + source_path + Override the source of from where the grammar was loaded. Useful for relative imports and unconventional grammar loading + **=== End of Options ===** + """ + if __doc__: + __doc__ += OPTIONS_DOC + + + ## + + ## + + ## + + ## + + ## + + ## + + _defaults: Dict[str, Any] = { + 'debug': False, + 'strict': False, + 'keep_all_tokens': False, + 'tree_class': None, + 'cache': False, + 'cache_grammar': False, + 'postlex': None, + 'parser': 'earley', + 'lexer': 'auto', + 'transformer': None, + 'start': 'start', + 'priority': 'auto', + 'ambiguity': 'auto', + 'regex': False, + 'propagate_positions': False, + 'lexer_callbacks': {}, + 'maybe_placeholders': True, + 'edit_terminals': None, + 'g_regex_flags': 0, + 'use_bytes': False, + 'ordered_sets': True, + 'import_paths': [], + 'source_path': None, + '_plugins': {}, + } + + def __init__(self, options_dict: Dict[str, Any]) -> None: + o = dict(options_dict) + + options = {} + for name, default in self._defaults.items(): + if name in o: + value = o.pop(name) + if isinstance(default, bool) and name not in ('cache', 'use_bytes', 'propagate_positions'): + value = bool(value) + else: + value = default + + options[name] = value + + if isinstance(options['start'], str): + options['start'] = [options['start']] + + self.__dict__['options'] = options + + + assert_config(self.parser, ('earley', 'lalr', 'cyk', None)) + + if self.parser == 'earley' and self.transformer: + raise ConfigurationError('Cannot specify an embedded transformer when using the Earley algorithm. ' + 'Please use your transformer on the resulting parse tree, or use a different algorithm (i.e. LALR)') + + if self.cache_grammar and not self.cache: + raise ConfigurationError('cache_grammar cannot be set when cache is disabled') + + if o: + raise ConfigurationError("Unknown options: %s" % o.keys()) + + def __getattr__(self, name: str) -> Any: + try: + return self.__dict__['options'][name] + except KeyError as e: + raise AttributeError(e) + + def __setattr__(self, name: str, value: str) -> None: + assert_config(name, self.options.keys(), "%r isn't a valid option. Expected one of: %s") + self.options[name] = value + + def serialize(self, memo = None) -> Dict[str, Any]: + return self.options + + @classmethod + def deserialize(cls, data: Dict[str, Any], memo: Dict[int, Union[TerminalDef, Rule]]) -> "LarkOptions": + return cls(data) + + +## + +## + +_LOAD_ALLOWED_OPTIONS = {'postlex', 'transformer', 'lexer_callbacks', 'use_bytes', 'debug', 'g_regex_flags', 'regex', 'propagate_positions', 'tree_class', '_plugins'} + +_VALID_PRIORITY_OPTIONS = ('auto', 'normal', 'invert', None) +_VALID_AMBIGUITY_OPTIONS = ('auto', 'resolve', 'explicit', 'forest') + + +_T = TypeVar('_T', bound="Lark") + +class Lark(Serialize): + #-- + + source_path: str + source_grammar: str + grammar: 'Grammar' + options: LarkOptions + lexer: Lexer + parser: 'ParsingFrontend' + terminals: Collection[TerminalDef] + + __serialize_fields__ = ['parser', 'rules', 'options'] + + def __init__(self, grammar: 'Union[Grammar, str, IO[str]]', **options) -> None: + self.options = LarkOptions(options) + re_module: types.ModuleType + + ## + + if self.options.cache_grammar: + self.__serialize_fields__ = self.__serialize_fields__ + ['grammar'] + + ## + + use_regex = self.options.regex + if use_regex: + if _has_regex: + re_module = regex + else: + raise ImportError('`regex` module must be installed if calling `Lark(regex=True)`.') + else: + re_module = re + + ## + + if self.options.source_path is None: + try: + self.source_path = grammar.name ## + + except AttributeError: + self.source_path = '' + else: + self.source_path = self.options.source_path + + ## + + try: + read = grammar.read ## + + except AttributeError: + pass + else: + grammar = read() + + cache_fn = None + cache_sha256 = None + if isinstance(grammar, str): + self.source_grammar = grammar + if self.options.use_bytes: + if not grammar.isascii(): + raise ConfigurationError("Grammar must be ascii only, when use_bytes=True") + + if self.options.cache: + if self.options.parser != 'lalr': + raise ConfigurationError("cache only works with parser='lalr' for now") + + unhashable = ('transformer', 'postlex', 'lexer_callbacks', 'edit_terminals', '_plugins') + options_str = ''.join(k+str(v) for k, v in options.items() if k not in unhashable) + from . import __version__ + s = grammar + options_str + __version__ + str(sys.version_info[:2]) + cache_sha256 = sha256_digest(s) + + if isinstance(self.options.cache, str): + cache_fn = self.options.cache + else: + if self.options.cache is not True: + raise ConfigurationError("cache argument must be bool or str") + + try: + username = getpass.getuser() + except Exception: + ## + + ## + + ## + + username = "unknown" + + + cache_fn = tempfile.gettempdir() + "/.lark_%s_%s_%s_%s_%s.tmp" % ( + "cache_grammar" if self.options.cache_grammar else "cache", username, cache_sha256, *sys.version_info[:2]) + + old_options = self.options + try: + with FS.open(cache_fn, 'rb') as f: + logger.debug('Loading grammar from cache: %s', cache_fn) + ## + + for name in (set(options) - _LOAD_ALLOWED_OPTIONS): + del options[name] + file_sha256 = f.readline().rstrip(b'\n') + cached_used_files = pickle.load(f) + if file_sha256 == cache_sha256.encode('utf8') and verify_used_files(cached_used_files): + cached_parser_data = pickle.load(f) + self._load(cached_parser_data, **options) + return + except FileNotFoundError: + ## + + pass + except Exception: ## + + logger.exception("Failed to load Lark from cache: %r. We will try to carry on.", cache_fn) + + ## + + ## + + self.options = old_options + + + ## + + self.grammar, used_files = load_grammar(grammar, self.source_path, self.options.import_paths, self.options.keep_all_tokens) + else: + assert isinstance(grammar, Grammar) + self.grammar = grammar + + + if self.options.lexer == 'auto': + if self.options.parser == 'lalr': + self.options.lexer = 'contextual' + elif self.options.parser == 'earley': + if self.options.postlex is not None: + logger.info("postlex can't be used with the dynamic lexer, so we use 'basic' instead. " + "Consider using lalr with contextual instead of earley") + self.options.lexer = 'basic' + else: + self.options.lexer = 'dynamic' + elif self.options.parser == 'cyk': + self.options.lexer = 'basic' + else: + assert False, self.options.parser + lexer = self.options.lexer + if isinstance(lexer, type): + assert issubclass(lexer, Lexer) ## + + else: + assert_config(lexer, ('basic', 'contextual', 'dynamic', 'dynamic_complete')) + if self.options.postlex is not None and 'dynamic' in lexer: + raise ConfigurationError("Can't use postlex with a dynamic lexer. Use basic or contextual instead") + + if self.options.ambiguity == 'auto': + if self.options.parser == 'earley': + self.options.ambiguity = 'resolve' + else: + assert_config(self.options.parser, ('earley', 'cyk'), "%r doesn't support disambiguation. Use one of these parsers instead: %s") + + if self.options.priority == 'auto': + self.options.priority = 'normal' + + if self.options.priority not in _VALID_PRIORITY_OPTIONS: + raise ConfigurationError("invalid priority option: %r. Must be one of %r" % (self.options.priority, _VALID_PRIORITY_OPTIONS)) + if self.options.ambiguity not in _VALID_AMBIGUITY_OPTIONS: + raise ConfigurationError("invalid ambiguity option: %r. Must be one of %r" % (self.options.ambiguity, _VALID_AMBIGUITY_OPTIONS)) + + if self.options.parser is None: + terminals_to_keep = '*' ## + + elif self.options.postlex is not None: + terminals_to_keep = set(self.options.postlex.always_accept) + else: + terminals_to_keep = set() + + ## + + self.terminals, self.rules, self.ignore_tokens = self.grammar.compile(self.options.start, terminals_to_keep) + + if self.options.edit_terminals: + for t in self.terminals: + self.options.edit_terminals(t) + + self._terminals_dict = {t.name: t for t in self.terminals} + + ## + + if self.options.priority == 'invert': + for rule in self.rules: + if rule.options.priority is not None: + rule.options.priority = -rule.options.priority + for term in self.terminals: + term.priority = -term.priority + ## + + ## + + ## + + elif self.options.priority is None: + for rule in self.rules: + if rule.options.priority is not None: + rule.options.priority = None + for term in self.terminals: + term.priority = 0 + + ## + + self.lexer_conf = LexerConf( + self.terminals, re_module, self.ignore_tokens, self.options.postlex, + self.options.lexer_callbacks, self.options.g_regex_flags, use_bytes=self.options.use_bytes, strict=self.options.strict + ) + + if self.options.parser: + self.parser = self._build_parser() + elif lexer: + self.lexer = self._build_lexer() + + if cache_fn: + logger.debug('Saving grammar to cache: %s', cache_fn) + try: + with FS.open(cache_fn, 'wb') as f: + assert cache_sha256 is not None + f.write(cache_sha256.encode('utf8') + b'\n') + pickle.dump(used_files, f) + self.save(f, _LOAD_ALLOWED_OPTIONS) + except IOError as e: + logger.exception("Failed to save Lark to cache: %r.", cache_fn, e) + + if __doc__: + __doc__ += "\n\n" + LarkOptions.OPTIONS_DOC + + def _build_lexer(self, dont_ignore: bool=False) -> BasicLexer: + lexer_conf = self.lexer_conf + if dont_ignore: + from copy import copy + lexer_conf = copy(lexer_conf) + lexer_conf.ignore = () + return BasicLexer(lexer_conf) + + def _prepare_callbacks(self) -> None: + self._callbacks = {} + ## + + if self.options.ambiguity != 'forest': + self._parse_tree_builder = ParseTreeBuilder( + self.rules, + self.options.tree_class or Tree, + self.options.propagate_positions, + self.options.parser != 'lalr' and self.options.ambiguity == 'explicit', + self.options.maybe_placeholders + ) + self._callbacks = self._parse_tree_builder.create_callback(self.options.transformer) + self._callbacks.update(_get_lexer_callbacks(self.options.transformer, self.terminals)) + + def _build_parser(self) -> "ParsingFrontend": + self._prepare_callbacks() + _validate_frontend_args(self.options.parser, self.options.lexer) + parser_conf = ParserConf(self.rules, self._callbacks, self.options.start) + return _construct_parsing_frontend( + self.options.parser, + self.options.lexer, + self.lexer_conf, + parser_conf, + options=self.options + ) + + def save(self, f, exclude_options: Collection[str] = ()) -> None: + #-- + if self.options.parser != 'lalr': + raise NotImplementedError("Lark.save() is only implemented for the LALR(1) parser.") + data, m = self.memo_serialize([TerminalDef, Rule]) + if exclude_options: + data["options"] = {n: v for n, v in data["options"].items() if n not in exclude_options} + pickle.dump({'data': data, 'memo': m}, f, protocol=pickle.HIGHEST_PROTOCOL) + + @classmethod + def load(cls: Type[_T], f) -> _T: + #-- + inst = cls.__new__(cls) + return inst._load(f) + + def _deserialize_lexer_conf(self, data: Dict[str, Any], memo: Dict[int, Union[TerminalDef, Rule]], options: LarkOptions) -> LexerConf: + lexer_conf = LexerConf.deserialize(data['lexer_conf'], memo) + lexer_conf.callbacks = options.lexer_callbacks or {} + lexer_conf.re_module = regex if options.regex else re + lexer_conf.use_bytes = options.use_bytes + lexer_conf.g_regex_flags = options.g_regex_flags + lexer_conf.skip_validation = True + lexer_conf.postlex = options.postlex + return lexer_conf + + def _load(self: _T, f: Any, **kwargs) -> _T: + if isinstance(f, dict): + d = f + else: + d = pickle.load(f) + memo_json = d['memo'] + data = d['data'] + + assert memo_json + memo = SerializeMemoizer.deserialize(memo_json, {'Rule': Rule, 'TerminalDef': TerminalDef}, {}) + if 'grammar' in data: + self.grammar = Grammar.deserialize(data['grammar'], memo) + options = dict(data['options']) + if (set(kwargs) - _LOAD_ALLOWED_OPTIONS) & set(LarkOptions._defaults): + raise ConfigurationError("Some options are not allowed when loading a Parser: {}" + .format(set(kwargs) - _LOAD_ALLOWED_OPTIONS)) + options.update(kwargs) + self.options = LarkOptions.deserialize(options, memo) + self.rules = [Rule.deserialize(r, memo) for r in data['rules']] + self.source_path = '' + _validate_frontend_args(self.options.parser, self.options.lexer) + self.lexer_conf = self._deserialize_lexer_conf(data['parser'], memo, self.options) + self.terminals = self.lexer_conf.terminals + self._prepare_callbacks() + self._terminals_dict = {t.name: t for t in self.terminals} + self.parser = _deserialize_parsing_frontend( + data['parser'], + memo, + self.lexer_conf, + self._callbacks, + self.options, ## + + ) + return self + + @classmethod + def _load_from_dict(cls, data, memo, **kwargs): + inst = cls.__new__(cls) + return inst._load({'data': data, 'memo': memo}, **kwargs) + + @classmethod + def open(cls: Type[_T], grammar_filename: str, rel_to: Optional[str]=None, **options) -> _T: + #-- + if rel_to: + basepath = os.path.dirname(rel_to) + grammar_filename = os.path.join(basepath, grammar_filename) + with open(grammar_filename, encoding='utf8') as f: + return cls(f, **options) + + @classmethod + def open_from_package(cls: Type[_T], package: str, grammar_path: str, search_paths: 'Sequence[str]'=[""], **options) -> _T: + #-- + package_loader = FromPackageLoader(package, search_paths) + full_path, text = package_loader(None, grammar_path) + options.setdefault('source_path', full_path) + options.setdefault('import_paths', []) + options['import_paths'].append(package_loader) + return cls(text, **options) + + def __repr__(self): + return 'Lark(open(%r), parser=%r, lexer=%r, ...)' % (self.source_path, self.options.parser, self.options.lexer) + + + def lex(self, text: TextOrSlice, dont_ignore: bool=False) -> Iterator[Token]: + #-- + lexer: Lexer + if not hasattr(self, 'lexer') or dont_ignore: + lexer = self._build_lexer(dont_ignore) + else: + lexer = self.lexer + lexer_thread = LexerThread.from_text(lexer, text) + stream = lexer_thread.lex(None) + if self.options.postlex: + return self.options.postlex.process(stream) + return stream + + def get_terminal(self, name: str) -> TerminalDef: + #-- + return self._terminals_dict[name] + + def parse_interactive(self, text: Optional[LarkInput]=None, start: Optional[str]=None) -> 'InteractiveParser': + #-- + return self.parser.parse_interactive(text, start=start) + + def parse(self, text: LarkInput, start: Optional[str]=None, on_error: 'Optional[Callable[[UnexpectedInput], bool]]'=None) -> 'ParseTree': + #-- + if on_error is not None and self.options.parser != 'lalr': + raise NotImplementedError("The on_error option is only implemented for the LALR(1) parser.") + return self.parser.parse(text, start=start, on_error=on_error) + + + + +class DedentError(LarkError): + pass + +class Indenter(PostLex, ABC): + #-- + paren_level: int + indent_level: List[int] + + def __init__(self) -> None: + self.paren_level = 0 + self.indent_level = [0] + assert self.tab_len > 0 + + def handle_NL(self, token: Token) -> Iterator[Token]: + if self.paren_level > 0: + return + + yield token + + indent_str = token.rsplit('\n', 1)[1] ## + + indent = indent_str.count(' ') + indent_str.count('\t') * self.tab_len + + if indent > self.indent_level[-1]: + self.indent_level.append(indent) + yield Token.new_borrow_pos(self.INDENT_type, indent_str, token) + else: + while indent < self.indent_level[-1]: + self.indent_level.pop() + yield Token.new_borrow_pos(self.DEDENT_type, indent_str, token) + + if indent != self.indent_level[-1]: + raise DedentError('Unexpected dedent to column %s. Expected dedent to %s' % (indent, self.indent_level[-1])) + + def _process(self, stream): + token = None + for token in stream: + if token.type == self.NL_type: + yield from self.handle_NL(token) + else: + yield token + + if token.type in self.OPEN_PAREN_types: + self.paren_level += 1 + elif token.type in self.CLOSE_PAREN_types: + self.paren_level -= 1 + assert self.paren_level >= 0 + + while len(self.indent_level) > 1: + self.indent_level.pop() + yield Token.new_borrow_pos(self.DEDENT_type, '', token) if token else Token(self.DEDENT_type, '', 0, 0, 0, 0, 0, 0) + + assert self.indent_level == [0], self.indent_level + + def process(self, stream): + self.paren_level = 0 + self.indent_level = [0] + return self._process(stream) + + ## + + @property + def always_accept(self): + return (self.NL_type,) + + @property + @abstractmethod + def NL_type(self) -> str: + #-- + raise NotImplementedError() + + @property + @abstractmethod + def OPEN_PAREN_types(self) -> List[str]: + #-- + raise NotImplementedError() + + @property + @abstractmethod + def CLOSE_PAREN_types(self) -> List[str]: + #-- + raise NotImplementedError() + + @property + @abstractmethod + def INDENT_type(self) -> str: + #-- + raise NotImplementedError() + + @property + @abstractmethod + def DEDENT_type(self) -> str: + #-- + raise NotImplementedError() + + @property + @abstractmethod + def tab_len(self) -> int: + #-- + raise NotImplementedError() + + +class PythonIndenter(Indenter): + #-- + + NL_type = '_NEWLINE' + OPEN_PAREN_types = ['LPAR', 'LSQB', 'LBRACE'] + CLOSE_PAREN_types = ['RPAR', 'RSQB', 'RBRACE'] + INDENT_type = '_INDENT' + DEDENT_type = '_DEDENT' + tab_len = 8 + + +import pickle, zlib, base64 +DATA = ( +{'parser': {'lexer_conf': {'terminals': [{'@': 0}, {'@': 1}, {'@': 2}, {'@': 3}, {'@': 4}, {'@': 5}, {'@': 6}, {'@': 7}, {'@': 8}, {'@': 9}, {'@': 10}, {'@': 11}, {'@': 12}], 'ignore': [], 'g_regex_flags': 0, 'use_bytes': False, 'lexer_type': 'basic', '__type__': 'LexerConf'}, 'parser_conf': {'rules': [{'@': 13}, {'@': 14}, {'@': 15}, {'@': 16}, {'@': 17}, {'@': 18}, {'@': 19}, {'@': 20}, {'@': 21}, {'@': 22}, {'@': 23}, {'@': 24}, {'@': 25}, {'@': 26}, {'@': 27}, {'@': 28}, {'@': 29}, {'@': 30}, {'@': 31}, {'@': 32}, {'@': 33}, {'@': 34}, {'@': 35}, {'@': 36}, {'@': 37}, {'@': 38}, {'@': 39}, {'@': 40}, {'@': 41}, {'@': 42}, {'@': 43}, {'@': 44}, {'@': 45}, {'@': 46}, {'@': 47}, {'@': 48}, {'@': 49}, {'@': 50}, {'@': 51}, {'@': 52}, {'@': 53}, {'@': 54}, {'@': 55}, {'@': 56}, {'@': 57}], 'start': ['start'], 'parser_type': 'lalr', '__type__': 'ParserConf'}, 'parser': {'tokens': {0: 'UNICODE_SCAPE', 1: 'OCTAL_SCAPE', 2: 'SINGLE', 3: 'TRIPLE_SINGLE', 4: 'SINGLE_SCAPE_SEQ', 5: 'NAMED_UNICODE_SCAPE', 6: 'UNRECOGNIZED_SCAPE_SEQ', 7: 'ANY', 8: 'DOUBLE', 9: 'STRING_PREFIX', 10: 'TRIPLE_DOUBLE', 11: 'HEX_SCAPE', 12: '__string_literal_star_1', 13: 'NEWLINE', 14: 'scape_seq', 15: 'triple_single_inner', 16: 'other_token', 17: '$END', 18: 'string_literal', 19: 'single_inner', 20: '__string_literal_star_3', 21: '__string_literal_star_2', 22: 'double_inner', 23: '__string_literal_star_0', 24: 'triple_double_inner', 25: 'start'}, 'states': {0: {0: (1, {'@': 36}), 1: (1, {'@': 36}), 2: (1, {'@': 36}), 3: (1, {'@': 36}), 4: (1, {'@': 36}), 5: (1, {'@': 36}), 6: (1, {'@': 36}), 7: (1, {'@': 36}), 8: (1, {'@': 36}), 9: (1, {'@': 36}), 10: (1, {'@': 36}), 11: (1, {'@': 36})}, 1: {2: (0, 51), 0: (0, 41), 12: (0, 48), 8: (0, 46), 13: (0, 39), 14: (0, 49), 1: (0, 42), 15: (0, 50), 3: (0, 44), 9: (0, 23), 5: (0, 30), 10: (0, 18), 7: (0, 11), 11: (0, 8), 16: (0, 25), 6: (0, 24), 4: (0, 31)}, 2: {13: (1, {'@': 50}), 0: (1, {'@': 50}), 1: (1, {'@': 50}), 2: (1, {'@': 50}), 3: (1, {'@': 50}), 5: (1, {'@': 50}), 4: (1, {'@': 50}), 6: (1, {'@': 50}), 7: (1, {'@': 50}), 8: (1, {'@': 50}), 9: (1, {'@': 50}), 10: (1, {'@': 50}), 11: (1, {'@': 50})}, 3: {17: (1, {'@': 21})}, 4: {3: (0, 1), 10: (0, 21), 18: (0, 27), 8: (0, 15), 2: (0, 10)}, 5: {8: (0, 38), 0: (0, 41), 10: (0, 9), 19: (0, 28), 2: (0, 3), 14: (0, 49), 1: (0, 42), 9: (0, 23), 6: (0, 24), 3: (0, 16), 7: (0, 11), 11: (0, 8), 16: (0, 40), 4: (0, 31), 5: (0, 30)}, 6: {17: (1, {'@': 20})}, 7: {0: (1, {'@': 55}), 1: (1, {'@': 55}), 2: (1, {'@': 55}), 3: (1, {'@': 55}), 4: (1, {'@': 55}), 5: (1, {'@': 55}), 6: (1, {'@': 55}), 7: (1, {'@': 55}), 8: (1, {'@': 55}), 9: (1, {'@': 55}), 10: (1, {'@': 55}), 11: (1, {'@': 55})}, 8: {0: (1, {'@': 47}), 13: (1, {'@': 47}), 1: (1, {'@': 47}), 2: (1, {'@': 47}), 3: (1, {'@': 47}), 5: (1, {'@': 47}), 4: (1, {'@': 47}), 6: (1, {'@': 47}), 7: (1, {'@': 47}), 8: (1, {'@': 47}), 9: (1, {'@': 47}), 10: (1, {'@': 47}), 11: (1, {'@': 47})}, 9: {0: (1, {'@': 38}), 1: (1, {'@': 38}), 2: (1, {'@': 38}), 3: (1, {'@': 38}), 4: (1, {'@': 38}), 5: (1, {'@': 38}), 6: (1, {'@': 38}), 7: (1, {'@': 38}), 8: (1, {'@': 38}), 9: (1, {'@': 38}), 10: (1, {'@': 38}), 11: (1, {'@': 38})}, 10: {8: (0, 38), 0: (0, 41), 19: (0, 53), 10: (0, 9), 14: (0, 49), 1: (0, 42), 2: (0, 14), 20: (0, 5), 9: (0, 23), 6: (0, 24), 3: (0, 16), 7: (0, 11), 11: (0, 8), 16: (0, 40), 4: (0, 31), 5: (0, 30)}, 11: {0: (1, {'@': 44}), 13: (1, {'@': 44}), 1: (1, {'@': 44}), 2: (1, {'@': 44}), 3: (1, {'@': 44}), 5: (1, {'@': 44}), 4: (1, {'@': 44}), 6: (1, {'@': 44}), 7: (1, {'@': 44}), 8: (1, {'@': 44}), 9: (1, {'@': 44}), 10: (1, {'@': 44}), 11: (1, {'@': 44})}, 12: {17: (1, {'@': 19})}, 13: {13: (1, {'@': 23}), 0: (1, {'@': 23}), 1: (1, {'@': 23}), 2: (1, {'@': 23}), 3: (1, {'@': 23}), 5: (1, {'@': 23}), 4: (1, {'@': 23}), 6: (1, {'@': 23}), 7: (1, {'@': 23}), 8: (1, {'@': 23}), 9: (1, {'@': 23}), 10: (1, {'@': 23}), 11: (1, {'@': 23})}, 14: {17: (1, {'@': 22})}, 15: {8: (0, 6), 10: (0, 19), 21: (0, 34), 16: (0, 17), 14: (0, 49), 2: (0, 0), 22: (0, 29), 1: (0, 42), 9: (0, 23), 3: (0, 35), 6: (0, 24), 7: (0, 11), 11: (0, 8), 0: (0, 41), 4: (0, 31), 5: (0, 30)}, 16: {0: (1, {'@': 39}), 1: (1, {'@': 39}), 2: (1, {'@': 39}), 3: (1, {'@': 39}), 4: (1, {'@': 39}), 5: (1, {'@': 39}), 6: (1, {'@': 39}), 7: (1, {'@': 39}), 8: (1, {'@': 39}), 9: (1, {'@': 39}), 10: (1, {'@': 39}), 11: (1, {'@': 39})}, 17: {0: (1, {'@': 33}), 1: (1, {'@': 33}), 2: (1, {'@': 33}), 3: (1, {'@': 33}), 4: (1, {'@': 33}), 5: (1, {'@': 33}), 6: (1, {'@': 33}), 7: (1, {'@': 33}), 8: (1, {'@': 33}), 9: (1, {'@': 33}), 10: (1, {'@': 33}), 11: (1, {'@': 33})}, 18: {0: (1, {'@': 29}), 13: (1, {'@': 29}), 1: (1, {'@': 29}), 2: (1, {'@': 29}), 3: (1, {'@': 29}), 5: (1, {'@': 29}), 4: (1, {'@': 29}), 6: (1, {'@': 29}), 7: (1, {'@': 29}), 8: (1, {'@': 29}), 9: (1, {'@': 29}), 10: (1, {'@': 29}), 11: (1, {'@': 29})}, 19: {0: (1, {'@': 34}), 1: (1, {'@': 34}), 2: (1, {'@': 34}), 3: (1, {'@': 34}), 4: (1, {'@': 34}), 5: (1, {'@': 34}), 6: (1, {'@': 34}), 7: (1, {'@': 34}), 8: (1, {'@': 34}), 9: (1, {'@': 34}), 10: (1, {'@': 34}), 11: (1, {'@': 34})}, 20: {17: (1, {'@': 15})}, 21: {23: (0, 33), 10: (0, 22), 13: (0, 37), 14: (0, 49), 1: (0, 42), 16: (0, 13), 24: (0, 2), 8: (0, 52), 9: (0, 23), 5: (0, 30), 6: (0, 24), 7: (0, 11), 11: (0, 8), 0: (0, 41), 4: (0, 31), 3: (0, 36), 2: (0, 26)}, 22: {17: (1, {'@': 16})}, 23: {0: (1, {'@': 43}), 13: (1, {'@': 43}), 1: (1, {'@': 43}), 2: (1, {'@': 43}), 3: (1, {'@': 43}), 5: (1, {'@': 43}), 4: (1, {'@': 43}), 6: (1, {'@': 43}), 7: (1, {'@': 43}), 8: (1, {'@': 43}), 9: (1, {'@': 43}), 10: (1, {'@': 43}), 11: (1, {'@': 43})}, 24: {0: (1, {'@': 42}), 13: (1, {'@': 42}), 1: (1, {'@': 42}), 2: (1, {'@': 42}), 3: (1, {'@': 42}), 5: (1, {'@': 42}), 4: (1, {'@': 42}), 6: (1, {'@': 42}), 7: (1, {'@': 42}), 8: (1, {'@': 42}), 9: (1, {'@': 42}), 10: (1, {'@': 42}), 11: (1, {'@': 42})}, 25: {0: (1, {'@': 28}), 13: (1, {'@': 28}), 1: (1, {'@': 28}), 2: (1, {'@': 28}), 3: (1, {'@': 28}), 5: (1, {'@': 28}), 4: (1, {'@': 28}), 6: (1, {'@': 28}), 7: (1, {'@': 28}), 8: (1, {'@': 28}), 9: (1, {'@': 28}), 10: (1, {'@': 28}), 11: (1, {'@': 28})}, 26: {13: (1, {'@': 26}), 0: (1, {'@': 26}), 1: (1, {'@': 26}), 2: (1, {'@': 26}), 3: (1, {'@': 26}), 5: (1, {'@': 26}), 4: (1, {'@': 26}), 6: (1, {'@': 26}), 7: (1, {'@': 26}), 8: (1, {'@': 26}), 9: (1, {'@': 26}), 10: (1, {'@': 26}), 11: (1, {'@': 26})}, 27: {17: (1, {'@': 13})}, 28: {0: (1, {'@': 57}), 1: (1, {'@': 57}), 2: (1, {'@': 57}), 3: (1, {'@': 57}), 4: (1, {'@': 57}), 5: (1, {'@': 57}), 6: (1, {'@': 57}), 7: (1, {'@': 57}), 8: (1, {'@': 57}), 9: (1, {'@': 57}), 10: (1, {'@': 57}), 11: (1, {'@': 57})}, 29: {0: (1, {'@': 54}), 1: (1, {'@': 54}), 2: (1, {'@': 54}), 3: (1, {'@': 54}), 4: (1, {'@': 54}), 5: (1, {'@': 54}), 6: (1, {'@': 54}), 7: (1, {'@': 54}), 8: (1, {'@': 54}), 9: (1, {'@': 54}), 10: (1, {'@': 54}), 11: (1, {'@': 54})}, 30: {0: (1, {'@': 48}), 13: (1, {'@': 48}), 1: (1, {'@': 48}), 2: (1, {'@': 48}), 3: (1, {'@': 48}), 5: (1, {'@': 48}), 4: (1, {'@': 48}), 6: (1, {'@': 48}), 7: (1, {'@': 48}), 8: (1, {'@': 48}), 9: (1, {'@': 48}), 10: (1, {'@': 48}), 11: (1, {'@': 48})}, 31: {0: (1, {'@': 45}), 13: (1, {'@': 45}), 1: (1, {'@': 45}), 2: (1, {'@': 45}), 3: (1, {'@': 45}), 5: (1, {'@': 45}), 4: (1, {'@': 45}), 6: (1, {'@': 45}), 7: (1, {'@': 45}), 8: (1, {'@': 45}), 9: (1, {'@': 45}), 10: (1, {'@': 45}), 11: (1, {'@': 45})}, 32: {0: (1, {'@': 53}), 13: (1, {'@': 53}), 1: (1, {'@': 53}), 2: (1, {'@': 53}), 3: (1, {'@': 53}), 5: (1, {'@': 53}), 4: (1, {'@': 53}), 6: (1, {'@': 53}), 7: (1, {'@': 53}), 8: (1, {'@': 53}), 9: (1, {'@': 53}), 10: (1, {'@': 53}), 11: (1, {'@': 53})}, 33: {10: (0, 20), 24: (0, 47), 13: (0, 37), 14: (0, 49), 1: (0, 42), 16: (0, 13), 8: (0, 52), 9: (0, 23), 5: (0, 30), 6: (0, 24), 7: (0, 11), 11: (0, 8), 0: (0, 41), 4: (0, 31), 3: (0, 36), 2: (0, 26)}, 34: {10: (0, 19), 16: (0, 17), 14: (0, 49), 2: (0, 0), 1: (0, 42), 8: (0, 12), 9: (0, 23), 3: (0, 35), 6: (0, 24), 22: (0, 7), 7: (0, 11), 11: (0, 8), 0: (0, 41), 4: (0, 31), 5: (0, 30)}, 35: {0: (1, {'@': 35}), 1: (1, {'@': 35}), 2: (1, {'@': 35}), 3: (1, {'@': 35}), 4: (1, {'@': 35}), 5: (1, {'@': 35}), 6: (1, {'@': 35}), 7: (1, {'@': 35}), 8: (1, {'@': 35}), 9: (1, {'@': 35}), 10: (1, {'@': 35}), 11: (1, {'@': 35})}, 36: {13: (1, {'@': 24}), 0: (1, {'@': 24}), 1: (1, {'@': 24}), 2: (1, {'@': 24}), 3: (1, {'@': 24}), 5: (1, {'@': 24}), 4: (1, {'@': 24}), 6: (1, {'@': 24}), 7: (1, {'@': 24}), 8: (1, {'@': 24}), 9: (1, {'@': 24}), 10: (1, {'@': 24}), 11: (1, {'@': 24})}, 37: {13: (1, {'@': 27}), 0: (1, {'@': 27}), 1: (1, {'@': 27}), 2: (1, {'@': 27}), 3: (1, {'@': 27}), 5: (1, {'@': 27}), 4: (1, {'@': 27}), 6: (1, {'@': 27}), 7: (1, {'@': 27}), 8: (1, {'@': 27}), 9: (1, {'@': 27}), 10: (1, {'@': 27}), 11: (1, {'@': 27})}, 38: {0: (1, {'@': 40}), 1: (1, {'@': 40}), 2: (1, {'@': 40}), 3: (1, {'@': 40}), 4: (1, {'@': 40}), 5: (1, {'@': 40}), 6: (1, {'@': 40}), 7: (1, {'@': 40}), 8: (1, {'@': 40}), 9: (1, {'@': 40}), 10: (1, {'@': 40}), 11: (1, {'@': 40})}, 39: {0: (1, {'@': 32}), 13: (1, {'@': 32}), 1: (1, {'@': 32}), 2: (1, {'@': 32}), 3: (1, {'@': 32}), 5: (1, {'@': 32}), 4: (1, {'@': 32}), 6: (1, {'@': 32}), 7: (1, {'@': 32}), 8: (1, {'@': 32}), 9: (1, {'@': 32}), 10: (1, {'@': 32}), 11: (1, {'@': 32})}, 40: {0: (1, {'@': 37}), 1: (1, {'@': 37}), 2: (1, {'@': 37}), 3: (1, {'@': 37}), 4: (1, {'@': 37}), 5: (1, {'@': 37}), 6: (1, {'@': 37}), 7: (1, {'@': 37}), 8: (1, {'@': 37}), 9: (1, {'@': 37}), 10: (1, {'@': 37}), 11: (1, {'@': 37})}, 41: {0: (1, {'@': 49}), 13: (1, {'@': 49}), 1: (1, {'@': 49}), 2: (1, {'@': 49}), 3: (1, {'@': 49}), 5: (1, {'@': 49}), 4: (1, {'@': 49}), 6: (1, {'@': 49}), 7: (1, {'@': 49}), 8: (1, {'@': 49}), 9: (1, {'@': 49}), 10: (1, {'@': 49}), 11: (1, {'@': 49})}, 42: {0: (1, {'@': 46}), 13: (1, {'@': 46}), 1: (1, {'@': 46}), 2: (1, {'@': 46}), 3: (1, {'@': 46}), 5: (1, {'@': 46}), 4: (1, {'@': 46}), 6: (1, {'@': 46}), 7: (1, {'@': 46}), 8: (1, {'@': 46}), 9: (1, {'@': 46}), 10: (1, {'@': 46}), 11: (1, {'@': 46})}, 43: {17: (1, {'@': 14})}, 44: {17: (1, {'@': 18})}, 45: {17: (1, {'@': 17})}, 46: {0: (1, {'@': 30}), 13: (1, {'@': 30}), 1: (1, {'@': 30}), 2: (1, {'@': 30}), 3: (1, {'@': 30}), 5: (1, {'@': 30}), 4: (1, {'@': 30}), 6: (1, {'@': 30}), 7: (1, {'@': 30}), 8: (1, {'@': 30}), 9: (1, {'@': 30}), 10: (1, {'@': 30}), 11: (1, {'@': 30})}, 47: {13: (1, {'@': 51}), 0: (1, {'@': 51}), 1: (1, {'@': 51}), 2: (1, {'@': 51}), 3: (1, {'@': 51}), 5: (1, {'@': 51}), 4: (1, {'@': 51}), 6: (1, {'@': 51}), 7: (1, {'@': 51}), 8: (1, {'@': 51}), 9: (1, {'@': 51}), 10: (1, {'@': 51}), 11: (1, {'@': 51})}, 48: {2: (0, 51), 0: (0, 41), 8: (0, 46), 13: (0, 39), 14: (0, 49), 15: (0, 32), 1: (0, 42), 9: (0, 23), 5: (0, 30), 10: (0, 18), 7: (0, 11), 11: (0, 8), 16: (0, 25), 6: (0, 24), 4: (0, 31), 3: (0, 45)}, 49: {0: (1, {'@': 41}), 13: (1, {'@': 41}), 1: (1, {'@': 41}), 2: (1, {'@': 41}), 3: (1, {'@': 41}), 5: (1, {'@': 41}), 4: (1, {'@': 41}), 6: (1, {'@': 41}), 7: (1, {'@': 41}), 8: (1, {'@': 41}), 9: (1, {'@': 41}), 10: (1, {'@': 41}), 11: (1, {'@': 41})}, 50: {0: (1, {'@': 52}), 13: (1, {'@': 52}), 1: (1, {'@': 52}), 2: (1, {'@': 52}), 3: (1, {'@': 52}), 5: (1, {'@': 52}), 4: (1, {'@': 52}), 6: (1, {'@': 52}), 7: (1, {'@': 52}), 8: (1, {'@': 52}), 9: (1, {'@': 52}), 10: (1, {'@': 52}), 11: (1, {'@': 52})}, 51: {0: (1, {'@': 31}), 13: (1, {'@': 31}), 1: (1, {'@': 31}), 2: (1, {'@': 31}), 3: (1, {'@': 31}), 5: (1, {'@': 31}), 4: (1, {'@': 31}), 6: (1, {'@': 31}), 7: (1, {'@': 31}), 8: (1, {'@': 31}), 9: (1, {'@': 31}), 10: (1, {'@': 31}), 11: (1, {'@': 31})}, 52: {13: (1, {'@': 25}), 0: (1, {'@': 25}), 1: (1, {'@': 25}), 2: (1, {'@': 25}), 3: (1, {'@': 25}), 5: (1, {'@': 25}), 4: (1, {'@': 25}), 6: (1, {'@': 25}), 7: (1, {'@': 25}), 8: (1, {'@': 25}), 9: (1, {'@': 25}), 10: (1, {'@': 25}), 11: (1, {'@': 25})}, 53: {0: (1, {'@': 56}), 1: (1, {'@': 56}), 2: (1, {'@': 56}), 3: (1, {'@': 56}), 4: (1, {'@': 56}), 5: (1, {'@': 56}), 6: (1, {'@': 56}), 7: (1, {'@': 56}), 8: (1, {'@': 56}), 9: (1, {'@': 56}), 10: (1, {'@': 56}), 11: (1, {'@': 56})}, 54: {}, 55: {18: (0, 43), 3: (0, 1), 10: (0, 21), 8: (0, 15), 2: (0, 10), 9: (0, 4), 25: (0, 54)}}, 'start_states': {'start': 55}, 'end_states': {'start': 54}}, '__type__': 'ParsingFrontend'}, 'rules': [{'@': 13}, {'@': 14}, {'@': 15}, {'@': 16}, {'@': 17}, {'@': 18}, {'@': 19}, {'@': 20}, {'@': 21}, {'@': 22}, {'@': 23}, {'@': 24}, {'@': 25}, {'@': 26}, {'@': 27}, {'@': 28}, {'@': 29}, {'@': 30}, {'@': 31}, {'@': 32}, {'@': 33}, {'@': 34}, {'@': 35}, {'@': 36}, {'@': 37}, {'@': 38}, {'@': 39}, {'@': 40}, {'@': 41}, {'@': 42}, {'@': 43}, {'@': 44}, {'@': 45}, {'@': 46}, {'@': 47}, {'@': 48}, {'@': 49}, {'@': 50}, {'@': 51}, {'@': 52}, {'@': 53}, {'@': 54}, {'@': 55}, {'@': 56}, {'@': 57}], 'options': {'debug': False, 'strict': False, 'keep_all_tokens': False, 'tree_class': None, 'cache': False, 'cache_grammar': False, 'postlex': None, 'parser': 'lalr', 'lexer': 'basic', 'transformer': None, 'start': ['start'], 'priority': 'normal', 'ambiguity': 'auto', 'regex': False, 'propagate_positions': False, 'lexer_callbacks': {}, 'maybe_placeholders': False, 'edit_terminals': None, 'g_regex_flags': 0, 'use_bytes': False, 'ordered_sets': True, 'import_paths': [], 'source_path': None, '_plugins': {}}, '__type__': 'Lark'} +) +MEMO = ( +{0: {'name': 'OCTAL_SCAPE', 'pattern': {'value': '\\\\(?:[0-7]){1,3}', 'flags': [], 'raw': None, '_width': [2, 4], '__type__': 'PatternRE'}, 'priority': 5, '__type__': 'TerminalDef'}, 1: {'name': 'HEX_SCAPE', 'pattern': {'value': '\\\\x(?:(?:[0-9]|[a-f]|[A-F])){2}', 'flags': [], 'raw': None, '_width': [4, 4], '__type__': 'PatternRE'}, 'priority': 5, '__type__': 'TerminalDef'}, 2: {'name': 'UNICODE_SCAPE', 'pattern': {'value': '(?:\\\\U(?:(?:[0-9]|[a-f]|[A-F])){8}|\\\\u(?:(?:[0-9]|[a-f]|[A-F])){4})', 'flags': [], 'raw': None, '_width': [6, 10], '__type__': 'PatternRE'}, 'priority': 5, '__type__': 'TerminalDef'}, 3: {'name': 'NAMED_UNICODE_SCAPE', 'pattern': {'value': '\\\\N\\{[a-zA-Z0-9 \\-]+\\}', 'flags': [], 'raw': None, '_width': [5, 18446744073709551616], '__type__': 'PatternRE'}, 'priority': 5, '__type__': 'TerminalDef'}, 4: {'name': 'NEWLINE', 'pattern': {'value': '\n', 'flags': [], 'raw': '"\\n"', '__type__': 'PatternStr'}, 'priority': 5, '__type__': 'TerminalDef'}, 5: {'name': 'STRING_PREFIX', 'pattern': {'value': '(?:(?i:br)|(?i:rb)|(?i:r)|(?i:u)|(?i:b))', 'flags': [], 'raw': None, '_width': [1, 2], '__type__': 'PatternRE'}, 'priority': 5, '__type__': 'TerminalDef'}, 6: {'name': 'TRIPLE_DOUBLE', 'pattern': {'value': '"""', 'flags': [], 'raw': '"\\"\\"\\""', '__type__': 'PatternStr'}, 'priority': 4, '__type__': 'TerminalDef'}, 7: {'name': 'TRIPLE_SINGLE', 'pattern': {'value': "'''", 'flags': [], 'raw': '"\'\'\'"', '__type__': 'PatternStr'}, 'priority': 4, '__type__': 'TerminalDef'}, 8: {'name': 'DOUBLE', 'pattern': {'value': '"', 'flags': [], 'raw': '"\\""', '__type__': 'PatternStr'}, 'priority': 3, '__type__': 'TerminalDef'}, 9: {'name': 'SINGLE', 'pattern': {'value': "'", 'flags': [], 'raw': '"\'"', '__type__': 'PatternStr'}, 'priority': 3, '__type__': 'TerminalDef'}, 10: {'name': 'SINGLE_SCAPE_SEQ', 'pattern': {'value': '\\\\[\n\\\\\\\'"abfnrtv]', 'flags': [], 'raw': '/\\\\[\\n\\\\\\\'\\"abfnrtv]/', '_width': [2, 2], '__type__': 'PatternRE'}, 'priority': 2, '__type__': 'TerminalDef'}, 11: {'name': 'UNRECOGNIZED_SCAPE_SEQ', 'pattern': {'value': '\\\\.', 'flags': ['s'], 'raw': '/\\\\./s', '_width': [2, 2], '__type__': 'PatternRE'}, 'priority': 1, '__type__': 'TerminalDef'}, 12: {'name': 'ANY', 'pattern': {'value': '[^"\'\\\\\n]+', 'flags': ['s'], 'raw': '/[^\\"\'\\\\\\n]+/s', '_width': [1, 18446744073709551616], '__type__': 'PatternRE'}, 'priority': 0, '__type__': 'TerminalDef'}, 13: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'STRING_PREFIX', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'string_literal', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 14: {'origin': {'name': 'start', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'string_literal', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 15: {'origin': {'name': 'string_literal', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TRIPLE_DOUBLE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '__string_literal_star_0', '__type__': 'NonTerminal'}, {'name': 'TRIPLE_DOUBLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 16: {'origin': {'name': 'string_literal', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TRIPLE_DOUBLE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'TRIPLE_DOUBLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 17: {'origin': {'name': 'string_literal', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TRIPLE_SINGLE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '__string_literal_star_1', '__type__': 'NonTerminal'}, {'name': 'TRIPLE_SINGLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 18: {'origin': {'name': 'string_literal', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TRIPLE_SINGLE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'TRIPLE_SINGLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 19: {'origin': {'name': 'string_literal', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DOUBLE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '__string_literal_star_2', '__type__': 'NonTerminal'}, {'name': 'DOUBLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 20: {'origin': {'name': 'string_literal', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DOUBLE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'DOUBLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 5, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 21: {'origin': {'name': 'string_literal', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SINGLE', 'filter_out': False, '__type__': 'Terminal'}, {'name': '__string_literal_star_3', '__type__': 'NonTerminal'}, {'name': 'SINGLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 6, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 22: {'origin': {'name': 'string_literal', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SINGLE', 'filter_out': False, '__type__': 'Terminal'}, {'name': 'SINGLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 7, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 23: {'origin': {'name': 'triple_double_inner', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'other_token', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 24: {'origin': {'name': 'triple_double_inner', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TRIPLE_SINGLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 25: {'origin': {'name': 'triple_double_inner', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DOUBLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 26: {'origin': {'name': 'triple_double_inner', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SINGLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 27: {'origin': {'name': 'triple_double_inner', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NEWLINE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 4, 'alias': 'string_token', 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 28: {'origin': {'name': 'triple_single_inner', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'other_token', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 29: {'origin': {'name': 'triple_single_inner', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TRIPLE_DOUBLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 30: {'origin': {'name': 'triple_single_inner', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DOUBLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 31: {'origin': {'name': 'triple_single_inner', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SINGLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 32: {'origin': {'name': 'triple_single_inner', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NEWLINE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 4, 'alias': 'string_token', 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 33: {'origin': {'name': 'double_inner', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'other_token', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 34: {'origin': {'name': 'double_inner', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TRIPLE_DOUBLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 35: {'origin': {'name': 'double_inner', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TRIPLE_SINGLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 36: {'origin': {'name': 'double_inner', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SINGLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': 'string_token', 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 37: {'origin': {'name': 'single_inner', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'other_token', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 38: {'origin': {'name': 'single_inner', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TRIPLE_DOUBLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 39: {'origin': {'name': 'single_inner', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'TRIPLE_SINGLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 40: {'origin': {'name': 'single_inner', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'DOUBLE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': 'string_token', 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 41: {'origin': {'name': 'other_token', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'scape_seq', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 42: {'origin': {'name': 'other_token', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UNRECOGNIZED_SCAPE_SEQ', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 43: {'origin': {'name': 'other_token', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'STRING_PREFIX', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 44: {'origin': {'name': 'other_token', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'ANY', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': True, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 45: {'origin': {'name': 'scape_seq', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'SINGLE_SCAPE_SEQ', 'filter_out': False, '__type__': 'Terminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 46: {'origin': {'name': 'scape_seq', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'OCTAL_SCAPE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 47: {'origin': {'name': 'scape_seq', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'HEX_SCAPE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 2, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 48: {'origin': {'name': 'scape_seq', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'NAMED_UNICODE_SCAPE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 3, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 49: {'origin': {'name': 'scape_seq', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'UNICODE_SCAPE', 'filter_out': False, '__type__': 'Terminal'}], 'order': 4, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 50: {'origin': {'name': '__string_literal_star_0', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'triple_double_inner', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 51: {'origin': {'name': '__string_literal_star_0', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__string_literal_star_0', '__type__': 'NonTerminal'}, {'name': 'triple_double_inner', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 52: {'origin': {'name': '__string_literal_star_1', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'triple_single_inner', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 53: {'origin': {'name': '__string_literal_star_1', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__string_literal_star_1', '__type__': 'NonTerminal'}, {'name': 'triple_single_inner', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 54: {'origin': {'name': '__string_literal_star_2', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'double_inner', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 55: {'origin': {'name': '__string_literal_star_2', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__string_literal_star_2', '__type__': 'NonTerminal'}, {'name': 'double_inner', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 56: {'origin': {'name': '__string_literal_star_3', '__type__': 'NonTerminal'}, 'expansion': [{'name': 'single_inner', '__type__': 'NonTerminal'}], 'order': 0, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}, 57: {'origin': {'name': '__string_literal_star_3', '__type__': 'NonTerminal'}, 'expansion': [{'name': '__string_literal_star_3', '__type__': 'NonTerminal'}, {'name': 'single_inner', '__type__': 'NonTerminal'}], 'order': 1, 'alias': None, 'options': {'keep_all_tokens': False, 'expand1': False, 'priority': None, 'template_source': None, 'empty_indices': (), '__type__': 'RuleOptions'}, '__type__': 'Rule'}} +) +Shift = 0 +Reduce = 1 +def Lark_StandAlone(**kwargs): + return Lark._load_from_dict(DATA, MEMO, **kwargs) diff --git a/omp4py/core/parser/transformer.py b/omp4py/core/parser/transformer.py new file mode 100644 index 0000000..b3c8304 --- /dev/null +++ b/omp4py/core/parser/transformer.py @@ -0,0 +1,1465 @@ +from __future__ import annotations + +import ast as pyast +from dataclasses import fields, MISSING +from typing import cast, get_type_hints, get_origin, get_args, Union, Iterable + +from . import tree +from .openmp_parser import Transformer, v_args, Token, Tree, Meta +from .source_view import SourceView + +__all__ = ["AstTransformer"] + +_DIRECTIVE_TYPES = { + "THREADPRIVATE_DIRECTIVE": tree.ThreadPrivate, + "DECLARE_REDUCTION_DIRECTIVE": tree.DeclareReduction, + "DECLARE_INDUCTION_DIRECTIVE": tree.DeclareInduction, + "SCAN_DIRECTIVE": tree.Scan, + "DECLARE_MAPPER_DIRECTIVE": tree.DeclareMapper, + "GROUPPRIVATE_DIRECTIVE": tree.GroupPrivate, + "ALLOCATE_DIRECTIVE": tree.Allocate, + "METADIRECTIVE_DIRECTIVE": tree.Metadirective, + "DECLARE_VARIANT_DIRECTIVE": tree.DeclareVariant, + "DISPATCH_DIRECTIVE": tree.Dispatch, + "DECLARE_SIMD_DIRECTIVE": tree.DeclareSimd, + "DECLARE_TARGET_DIRECTIVE": tree.DeclareTarget, + "REQUIRES_DIRECTIVE": tree.Requires, + "ASSUME_DIRECTIVE": tree.Assume, + "NOTHING_DIRECTIVE": tree.Nothing, + "ERROR_DIRECTIVE": tree.Error, + "FUSE_DIRECTIVE": tree.Fuse, + "INTERCHANGE_DIRECTIVE": tree.Interchange, + "SPLIT_DIRECTIVE": tree.Split, + "STRIPE_DIRECTIVE": tree.Stripe, + "TILE_DIRECTIVE": tree.Tile, + "UNROLL_DIRECTIVE": tree.Unroll, + "PARALLEL_DIRECTIVE": tree.Parallel, + "TEAMS_DIRECTIVE": tree.Teams, + "SIMD_DIRECTIVE": tree.Simd, + "MASKED_DIRECTIVE": tree.Masked, + "SINGLE_DIRECTIVE": tree.Single, + "SCOPE_DIRECTIVE": tree.Scope, + "SECTIONS_DIRECTIVE": tree.Sections, + "SECTION_DIRECTIVE": tree.Section, + "WORKSHARE_DIRECTIVE": tree.Workshare, + "WORKDISTRIBUTE_DIRECTIVE": tree.Workdistribute, + "FOR_DIRECTIVE": tree.For, + "DISTRIBUTE_DIRECTIVE": tree.Distribute, + "LOOP_DIRECTIVE": tree.Loop, + "TASK_DIRECTIVE": tree.Task, + "TASKLOOP_DIRECTIVE": tree.Taskloop, + "TASK_ITERATION_DIRECTIVE": tree.TaskIteration, + "TASKYIELD_DIRECTIVE": tree.Taskyield, + "TASKGRAPH_DIRECTIVE": tree.Taskgraph, + "TARGET_DATA_DIRECTIVE": tree.TargetData, + "TARGET_ENTER_DATA_DIRECTIVE": tree.TargetEnterData, + "TARGET_EXIT_DATA_DIRECTIVE": tree.TargetExitData, + "TARGET_DIRECTIVE": tree.Target, + "TARGET_UPDATE_DIRECTIVE": tree.TargetUpdate, + "INTEROP_DIRECTIVE": tree.InteropConstruct, + "CRITICAL_DIRECTIVE": tree.Critical, + "BARRIER_DIRECTIVE": tree.Barrier, + "TASKGROUP_DIRECTIVE": tree.Taskgroup, + "TASKWAIT_DIRECTIVE": tree.Taskwait, + "ATOMIC_DIRECTIVE": tree.Atomic, + "FLUSH_DIRECTIVE": tree.Flush, + "DEPOBJ_DIRECTIVE": tree.Depobj, + "ORDERED_DIRECTIVE": tree.Ordered, + "CANCEL_DIRECTIVE": tree.Cancel, + "CANCELLATION_POINT_DIRECTIVE": tree.CancellationPoint, +} + +# TODO: possible lru_cache here +def _has_field(field_name: str, obj: type, ignore: set[str] = {"span", "name"}) -> bool: + if field_name in ignore: + return False + field_names = {f.name for f in fields(obj)} + return field_name in field_names + +# TODO: possible lru_cache here +def _required_fields(cls: type, ignore: set[str] = {"span", "name"}) -> set[str]: + return { + f.name + for f in fields(cls) + if f.init and f.default is MISSING and f.default_factory is MISSING and f.name not in ignore + } + +def _is_clause_type(hint) -> bool: + origin = get_origin(hint) + if origin is list: + args = get_args(hint) + return bool(args) and isinstance(args[0], type) and issubclass(args[0], tree.Clause) + + if origin is Union: + args = get_args(hint) + return any(_is_clause_type(a) for a in args if a is not type(None)) + + return isinstance(hint, type) and issubclass(hint, tree.Clause) + + +@v_args(tree=True) +class AstTransformer(Transformer): + + def __init__(self, sv: SourceView) -> None: + super().__init__() + self.sv = sv + + #### HELPERS ############################################################### + + # No type here, otherwise cast() will be required everywhere + def _name_from_token(self, token) -> tree.Name: + return tree.Name(span=self.sv.token2span(token), string=str(token)) + + #### PYTHON CODE HELPERS ################################################### + + # Retrieves the original code and passes it to ast.parse() + def _parse_py_code(self, meta: Meta) -> tuple[pyast.Module, tree.Span, str]: + try: + # Get the source of the expression and pass it to ast.parse() + span = self.sv.meta2span(meta) + source = self.sv.source_text(span) + + # Clean up leading whitespace, as it will be treated as indentation + source_stripped = source.lstrip() + leading_ws = len(source) - len(source_stripped) + + code = pyast.parse(source_stripped) + code = self._apply_span(code, span, leading_ws) + return code, span, source + + except SyntaxError as e: + # Adjust the error position to show it within its context + err_line = e.lineno or 1 + err_end_line = e.end_lineno or err_line + err_col = e.offset or 1 + err_end_col = e.end_offset or err_col + span = tree.Span( + *self.sv.absolute_position(span, err_line, err_col, leading_ws), + *self.sv.absolute_position(span, err_end_line, err_end_col, leading_ws), + ) + + msg = f"invalid Python code: {e.msg}" + raise self.sv.syntax_error(msg, span) from None + + # Modifies the Python AST's positions so they are relative to the whole file + def _apply_span[T: pyast.AST](self, code: T, span: tree.Span, leading_ws: int = 0) -> T: + node: pyast.AST + for node in pyast.walk(code): + starts_on_first_line = False + + if hasattr(node, "lineno"): + starts_on_first_line = node.lineno == 1 + node.lineno += span.lineno - 1 # ty:ignore[unsupported-operator] # zuban:ignore[attr-defined] + + if hasattr(node, "end_lineno"): + ends_on_first_line = node.end_lineno == 1 + node.end_lineno += span.lineno - 1 # ty:ignore[unsupported-operator] # zuban:ignore[attr-defined] + else: + # Assume single-line node + ends_on_first_line = starts_on_first_line + + if starts_on_first_line and hasattr(node, "col_offset"): + node.col_offset += span.offset + leading_ws # ty:ignore[unsupported-operator] # zuban:ignore[attr-defined] + + if ends_on_first_line and hasattr(node, "end_col_offset"): + node.end_col_offset += span.offset + leading_ws # ty:ignore[unsupported-operator] # zuban:ignore[attr-defined] + return code + + #### CLAUSE HELPERS ######################################################## + + # Handles clause rules with one optional modifier and a single argument + # private_clause: PRIVATE_CLAUSE "(" [directive_name ":"] var_list ")" + # ==> _simple_clause(tree.Private, "targets", node) + def _simple_clause[T: tree.Clause](self, cls: type[T], field: str, node: Tree) -> T: + span = self.sv.meta2span(node.meta) + name = self._name_from_token(node.children[0]) + + directive_name = None + if len(node.children) == 3 and isinstance(node.children[1], tree.DirectiveName): + directive_name = node.children[1] + arg = ( + node.children[2].children[0] + if isinstance(node.children[2], Tree) + else node.children[2] + ) + elif len(node.children) == 2: + arg = ( + node.children[1].children[0] + if isinstance(node.children[1], Tree) + else node.children[1] + ) + elif len(node.children) == 1: + arg = None + else: + assert False, "_simple_clause() used on a complex clause" + + return cls(span=span, name=name, directive_name=directive_name, **{field: arg}) + + # IMPORTANT: don't use when the modifier can be repeated + def _clause_with_mods[T: tree.Clause]( + self, + cls: type[T], + meta: Meta, + token, + mod_list: list, + **kwargs + ) -> T: + span = self.sv.meta2span(meta) + assert isinstance(token, Token) + name = self._name_from_token(token) + + for mod in mod_list: + if mod is None: + continue + + field_name: str + if isinstance(mod, Tree): + assert _has_field(mod.data, cls), "Incorrect grammar: rule name does not match field" + assert len(mod.children) == 1, "Incorrect grammar: modifier rules must be a single token" + field_name = mod.data + mod = ( + mod.children[0] + if isinstance(mod.children[0], tree.Modifier) + else self._name_from_token(mod.children[0]) + ) + elif isinstance(mod, tree.Modifier): + field_name = mod.id + else: + raise TypeError(f"unexpected modifier kind: {mod!r}") + + if field_name in kwargs: + raise self.sv.syntax_error( + f'"{field_name}" modifier is already defined for {cls.id} clause.', span, + diagnostics=[("first defined here", kwargs[field_name].span)] + ) + kwargs[field_name] = mod + + # Before creating the final object, check if the required fields are set + missing = _required_fields(cls) - kwargs.keys() + if missing: + raise self.sv.syntax_error( + f'missing required modifier{"s" if len(missing) != 1 else ""} for {name} clause.', + span, + diagnostics=[ + f'missing "{field}" modifier' + for field in sorted(missing) + ], + ) + + return cls(span=span, name=name, **kwargs) + + + #### CONSTRUCT HELPERS ##################################################### + + def _construct_with_rejected[T: tree.Construct]( + self, + meta: Meta, + name: Token, + clause_list: Iterable[tree.Clause|None], + **extra_args, + ) -> tuple[T, list[tree.Clause]]: + # TODO: innermost-leaf or outermost-leaf properties are not handled here + + cls: type[T] = _DIRECTIVE_TYPES[name.type] # ty:ignore[invalid-assignment] # zuban:ignore[assignment] + span = self.sv.meta2span(meta) + type_hints = get_type_hints(cls) + + rejected = [] + kwargs: dict[str, tree.Clause|list[tree.Clause]] = {} + for clause in clause_list: + if clause is None: + continue + + if ( + not _has_field(clause.id, cls) or + (clause.directive_name is not None and clause.directive_name.string != cls.id) + ): + rejected.append(clause) + continue + + if clause.id in kwargs: + current = kwargs[clause.id] + + # If the construct's field is a list, append the new clause + if isinstance(current, list): + current.append(clause) # ty:ignore[invalid-argument-type] + + # Otherwise, means that the construct's field has already been set, + # so the clause is duplicated. Therefore, raise an error. + else: + raise self.sv.syntax_error( + # In the case of "if_" or "for_", remove those underscores + f"{clause.id.strip('_')} clause can only be defined once.", + clause.span, + diagnostics=[("first defined here", current.span)], + ) + + else: + # If it wasn't already set, check based on the type + # whether the clause is repeteable or not. + hint = type_hints[clause.id] + original_type = get_origin(hint) + type_args = get_args(hint) + + # If the type is something like list[Private] or list[Reduction], + # it means that this clause is repeatable. + if original_type is list and type_args and issubclass(type_args[0], tree.Clause): + kwargs[clause.id] = [clause] + else: + kwargs[clause.id] = clause + + # Before creating the final object, check if the required fields are set + missing_required_fields = { + e + for e in _required_fields(cls) - kwargs.keys() + if _is_clause_type(type_hints[e]) + } + if missing_required_fields: + raise self.sv.syntax_error( + f"missing required clause{"s" if len(missing_required_fields) != 1 else ""} for {cls.id} directive.", + span, + diagnostics=[ + f"missing {missing} clause." + for missing in sorted(missing_required_fields) + ], + ) + + return cls( + span=span, + name=self._name_from_token(name), + **kwargs, + **extra_args + ), rejected + + def _construct[T: tree.Construct]( + self, + meta: Meta, + name: Token, + clause_list: Iterable[tree.Clause|None], + **extra_args, + ) -> T: + construct, clause_list = self._construct_with_rejected(meta, name, clause_list, **extra_args) # zuban:ignore[var-annotated] + if clause_list: + raise self.sv.syntax_error( + f"some clauses were not used in this construct.", + construct.span, + diagnostics=[ + (f"{clause.id} clause was not used.", clause.span) + for clause in clause_list + ] + ) + return construct + + #### TOKENS ################################################################ + + @v_args(inline=True) + def IDENTIFIER(self, token: Token) -> tree.PyName: + span = self.sv.token2span(token) + + # This ensures that the token is considered an identifier by Python + if not token.value.isidentifier(): + raise self.sv.syntax_error("invalid characters found in identifier", span) + + return tree.PyName(span=span, string=token.value) + + @v_args(inline=True) + def INTEGER(self, token: Token) -> tree.PyInt: + # The int() conversion is safe to do here because the parser guarantees only digits + # Also, if the base is 0, Python will correctly guess it based on the prefix: + # XXX ==> Base 10 + # 0bXXXX ==> Base 2 + # 0oXXX ==> Base 8 + # 0xXX ==> Base 16 + return tree.PyInt(span=self.sv.token2span(token), value=int(token, 0)) + + #### COMMON DEFINITIONS #################################################### + + def py_expr(self, node: Tree) -> tree.PyExpr: + code, span, source = self._parse_py_code(node.meta) + + if not code.body or len(code.body) != 1 or not isinstance(code.body[0], pyast.Expr): + raise self.sv.syntax_error("expected expression", span) + + return tree.PyExpr( + span = span, + value = code.body[0].value, + source = source, + ) + + def py_stmt(self, node: Tree) -> tree.PyStmt: + code, span, source = self._parse_py_code(node.meta) + + if not code.body or len(code.body) != 1: + raise self.sv.syntax_error("expected a single statement", span) + + return tree.PyStmt( + span = span, + value = code.body[0], + source = source, + ) + + # var_list: IDENTIFIER ("," IDENTIFIER)* + def var_list(self, node: Tree) -> list[tree.PyName]: + return list(cast("list[tree.PyName]", node.children)) + + # expr_list: py_expr ("," py_expr)* + def expr_list(self, node: Tree) -> list[tree.PyExpr]: + return list(cast("list[tree.PyExpr]", node.children)) + + # stmt_list: py_stmt ("," py_stmt)* + def stmt_list(self, node: Tree) -> list[tree.PyStmt]: + return list(cast("list[tree.PyStmt]", node.children)) + + # Rule to alias from the grammar + def name(self, node: Tree) -> tree.Name: + return self._name_from_token(node.children[0]) + + @v_args(inline=True) + def directive_name(self, token: Token) -> tree.DirectiveName: + return tree.DirectiveName(span=self.sv.token2span(token), string=_DIRECTIVE_TYPES[token.type].id) + + def directive_list(self, node: Tree) -> list[tree.DirectiveName]: + return list(cast("list[tree.DirectiveName]", node.children)) + + #### MODIFIERS ############################################################# + + # reduction_op: IDENTIFIER | PLUS | MINUS | MULT | ... + @v_args(inline=True) + def reduction_op(self, token: Token|tree.PyName) -> tree.ReductionOp: + if isinstance(token, tree.PyName): + return tree.ReductionOp(span=token.span, value=token.string) + return tree.ReductionOp(span=self.sv.token2span(token), value=str(token)) + + # induction_op: IDENTIFIER | PLUS | MULT + @v_args(inline=True) + def induction_op(self, token: Token|tree.PyName) -> tree.InductionOp: + if isinstance(token, tree.PyName): + return tree.InductionOp(span=token.span, value=token.string) + return tree.InductionOp(span=self.sv.token2span(token), value=str(token)) + + # original_modifier: ORIGINAL "(" (DEFAULT | PRIVATE | SHARED) ")" + @v_args(inline=True, meta=True) + def original_modifier(self, meta: Meta, token: Token, sharing_name: Token) -> tree.Original: + return tree.Original( + span=self.sv.meta2span(meta), + name=self._name_from_token(token), + sharing_name=self._name_from_token(sharing_name), + ) + + # iterator_modifier: ITERATOR "(" iterator_specifier ("," iterator_specifier)* ")" + def iterator_modifier(self, node: Tree) -> tree.Iterator: + return tree.Iterator( + span=self.sv.meta2span(node.meta), + name=self._name_from_token(node.children[0]), + specifiers=cast("list[tree.IteratorSpecifier]", node.children[1:]), + ) + + # iterator_specifier: IDENTIFIER "=" py_expr ":" py_expr [":" py_expr] + @v_args(inline=True, meta=True) + def iterator_specifier( + self, meta: Meta, + name: tree.PyName, + begin: tree.PyExpr, end: tree.PyExpr, step: tree.PyExpr|None + ) -> tree.IteratorSpecifier: + return tree.IteratorSpecifier( + span=self.sv.meta2span(meta), + name=name, begin=begin, end=end, step=step, + ) + + # step_modifier: STEP "(" py_expr ")" + @v_args(inline=True, meta=True) + def step_modifier(self, meta: Meta, token: Token, expr: tree.PyExpr) -> tree.Step: + return tree.Step( + span=self.sv.meta2span(meta), + name=self._name_from_token(token), + expr=expr, + ) + + # allocator_modifier: ALLOCATOR "(" py_expr ")" + @v_args(inline=True, meta=True) + def allocator_modifier(self, meta: Meta, token: Token, expr: tree.PyExpr) -> tree.AllocatorModifier: + return tree.AllocatorModifier( + span=self.sv.meta2span(meta), + name=self._name_from_token(token), + allocator=expr, + ) + + # align_modifier: ALIGN "(" py_expr ")" + @v_args(inline=True, meta=True) + def align_modifier(self, meta: Meta, token: Token, expr: tree.PyExpr) -> tree.AlignModifier: + return tree.AlignModifier( + span=self.sv.meta2span(meta), + name=self._name_from_token(token), + alignment=expr, + ) + + # mapper_modifier: MAPPER "(" IDENTIFIER ")" + @v_args(inline=True, meta=True) + def mapper_modifier(self, meta: Meta, token: Token, identifier: tree.PyName) -> tree.Mapper: + return tree.Mapper( + span=self.sv.meta2span(meta), + name=self._name_from_token(token), + identifier=identifier, + ) + + # memspace_modifier: MEMSPACE "(" py_expr ")" + @v_args(inline=True, meta=True) + def memspace_modifier(self, meta: Meta, token: Token, handle: tree.PyExpr) -> tree.MemSpace: + return tree.MemSpace( + span=self.sv.meta2span(meta), + name=self._name_from_token(token), + handle=handle, + ) + + # traits_modifier: TRAITS "(" py_expr ")" + @v_args(inline=True, meta=True) + def traits_modifier(self, meta: Meta, token: Token, traits: tree.PyExpr) -> tree.Traits: + return tree.Traits( + span=self.sv.meta2span(meta), + name=self._name_from_token(token), + traits=traits, + ) + + # depinfo_modifier: (IN | INOUT| INOUTSET | MUTEXINOUTSET | OUT) "(" var_list ")" + @v_args(inline=True, meta=True) + def depinfo_modifier(self, meta: Meta, token: Token, locator_list: list[tree.PyName]) -> tree.DepInfo: + return tree.DepInfo( + span=self.sv.meta2span(meta), + name=self._name_from_token(token), + locator_list=locator_list, + ) + + # loop_modifier: (FUSED | GRID | ...) ["(" expr_list ")"] + @v_args(inline=True, meta=True) + def loop_modifier(self, meta: Meta, token: Token, indices: list[tree.PyExpr]|None) -> tree.LoopModifier: + return tree.LoopModifier( + span=self.sv.meta2span(meta), + name=self._name_from_token(token), + indices=indices or [], + ) + + # FR "(" IDENTIFIER ")" -> fr_selector + @v_args(inline=True, meta=True) + def fr_selector(self, meta: Meta, token: Token, identifier: tree.PyName) -> tree.FrSelector: + return tree.FrSelector( + span = self.sv.meta2span(meta), + name = self._name_from_token(token), + identifier = identifier, + ) + + # ATTR "(" expr_list ")" -> attr_selector + @v_args(inline=True, meta=True) + def attr_selector(self, meta: Meta, token: Token, expr_list: list[tree.PyExpr]) -> tree.AttrSelector: + return tree.AttrSelector( + span = self.sv.meta2span(meta), + name = self._name_from_token(token), + expr_list = expr_list, + ) + + # prefer_type_modifier: PREFER_TYPE "(" preference_specification ("," preference_specification )* ")" + # preference_specification: "{" _preference_selector ("," _preference_selector)* "}" | IDENTIFIER + def prefer_type_modifier(self, node: Tree) -> tree.Prefer: + return tree.Prefer( + span=self.sv.meta2span(node.meta), + name=self._name_from_token(node.children[0]), + spec=[s if isinstance(s, tree.PyName) else list(s.children) for s in node.children[1:]] # ty:ignore[invalid-argument-type] # zuban:ignore[arg-type] + ) + + # append_op: INTEROP "(" _interop_type ("," _interop_type)* ")" + def append_op(self, node: Tree) -> tree.InteropModifier: + return tree.InteropModifier( + span=self.sv.meta2span(node.meta), + name=self._name_from_token(node.children[0]), + kind_name=cast("list[tree.Name]", node.children[1:]) + ) + + # TODO: this uses context_selector as a stmt_list, which is not exactly what the standard required + # context_selector: stmt_list + @v_args(inline=True, meta=True) + def context_selector(self, meta: Meta, stmt_list: list[tree.PyStmt]) -> tree.ContextSelector: + return tree.ContextSelector(span=self.sv.meta2span(meta), stmt_list=stmt_list) + + # schedule_type: STATIC | DYNAMIC | GUIDED | AUTO | RUNTIME + @v_args(inline=True) + def schedule_type(self, token: Token) -> tree.ScheduleType: + span = self.sv.token2span(token) + name = tree.Name(span=span, string=str(token)) + return tree.ScheduleType(span=span, kind_name=name) + + #### CLAUSES ############################################################### + + # combiner_clause: COMBINER_CLAUSE "(" [directive_name ":"] py_stmt ")" + def combiner_clause(self, node: Tree) -> tree.Combiner: + return self._simple_clause(tree.Combiner, "combiner_stmt", node) + + # initializer_clause: INITIALIZER_CLAUSE "(" [directive_name ":"] py_stmt ")" + def initializer_clause(self, node: Tree) -> tree.Initializer: + return self._simple_clause(tree.Initializer, "initializer_stmt", node) + + # inductor_clause: INDUCTOR_CLAUSE "(" [directive_name ":"] py_stmt ")" + def inductor_clause(self, node: Tree) -> tree.Inductor: + return self._simple_clause(tree.Inductor, "inductor_stmt", node) + + # collector_clause: COLLECTOR_CLAUSE "(" [directive_name ":"] py_expr ")" + def collector_clause(self, node: Tree) -> tree.Collector: + return self._simple_clause(tree.Collector, "collector_expr", node) + + # exclusive_clause: EXCLUSIVE_CLAUSE "(" [directive_name ":"] var_list ")" + def exclusive_clause(self, node: Tree) -> tree.Exclusive: + return self._simple_clause(tree.Exclusive, "targets", node) + + # inclusive_clause: INCLUSIVE_CLAUSE "(" [directive_name ":"] var_list ")" + def inclusive_clause(self, node: Tree) -> tree.Inclusive: + return self._simple_clause(tree.Inclusive, "targets", node) + + # init_complete_clause: INIT_COMPLETE_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def init_complete_clause(self, node: Tree) -> tree.InitComplete: + return self._simple_clause(tree.InitComplete, "create_init_phase", node) + + # device_type_clause: DEVICE_TYPE_CLAUSE "(" [directive_name ":"] device_type_kind ")" + def device_type_clause(self, node: Tree) -> tree.DeviceType: + return self._simple_clause(tree.DeviceType, "device_type_description_name", node) + + # align_clause: ALIGN_CLAUSE "(" [directive_name ":"] py_expr ")" + def align_clause(self, node: Tree) -> tree.Align: + return self._simple_clause(tree.Align, "alignment", node) + + # allocator_clause: ALLOCATOR_CLAUSE "(" [directive_name ":"] py_expr ")" + def allocator_clause(self, node: Tree) -> tree.Allocator: + return self._simple_clause(tree.Allocator, "allocator", node) + + # when_clause: WHEN_CLAUSE "(" _when_modifier_list ":" start ")" + def when_clause(self, node: Tree) -> tree.When: + return self._clause_with_mods( + tree.When, node.meta, node.children[0], node.children[1:-1], + directive=node.children[-1] + ) + + # otherwise_clause: OTHERWISE_CLAUSE ["(" [directive_name ":"] start ")"] + def otherwise_clause(self, node: Tree) -> tree.Otherwise: + return self._simple_clause(tree.Otherwise, "directive", node) + + # adjust_args_clause: ADJUST_ARGS_CLAUSE "(" _adjust_args_modifier_list ":" var_list ")" + def adjust_args_clause(self, node: Tree) -> tree.AdjustArgs: + return self._clause_with_mods( + tree.AdjustArgs, node.meta, node.children[0], node.children[1:-1], + targets=node.children[-1] + ) + + # append_args_clause: APPEND_ARGS_CLAUSE "(" [directive_name ":"] append_args_arg ")" + def append_args_clause(self, node: Tree) -> tree.AppendArgs: + return self._simple_clause(tree.AppendArgs, "append_op", node) + + # match_clause: MATCH_CLAUSE "(" [directive_name ":"] context_selector ")" + def match_clause(self, node: Tree) -> tree.Match: + return self._simple_clause(tree.Match, "context_selector", node) + + # interop_clause: INTEROP_CLAUSE "(" [directive_name ":"] var_list ")" + def interop_clause(self, node: Tree) -> tree.InteropClause: + return self._simple_clause(tree.InteropClause, "targets", node) + + # is_device_ptr_clause: IS_DEVICE_PTR_CLAUSE "(" [directive_name ":"] var_list ")" + def is_device_ptr_clause(self, node: Tree) -> tree.IsDevicePtr: + return self._simple_clause(tree.IsDevicePtr, "targets", node) + + # has_device_addr_clause: HAS_DEVICE_ADDR_CLAUSE "(" [directive_name ":"] var_list ")" + def has_device_addr_clause(self, node: Tree) -> tree.HasDeviceAddr: + return self._simple_clause(tree.HasDeviceAddr, "targets", node) + + # nocontext_clause: NOCONTEXT_CLAUSE "(" [directive_name ":"] py_expr ")" + def nocontext_clause(self, node: Tree) -> tree.NoContext: + return self._simple_clause(tree.NoContext, "dont_update_context", node) + + # novariants_clause: NOVARIANTS_CLAUSE "(" [directive_name ":"] py_expr ")" + def novariants_clause(self, node: Tree) -> tree.NoVariants: + return self._simple_clause(tree.NoVariants, "dont_use_variant", node) + + # aligned_clause: ALIGNED_CLAUSE "(" var_list [":" _aligned_modifier_list] ")" + def aligned_clause(self, node: Tree) -> tree.Aligned: + return self._clause_with_mods( + tree.Aligned, node.meta, node.children[0], node.children[2:], + targets=node.children[1] + ) + + # linear_clause: LINEAR_CLAUSE "(" var_list [":" _linear_modifier_list] ")" + def linear_clause(self, node: Tree) -> tree.Linear: + return self._clause_with_mods( + tree.Linear, node.meta, node.children[0], node.children[2:], + targets=node.children[1] + ) + + # simdlen_clause: SIMDLEN_CLAUSE "(" [directive_name ":"] py_expr ")" + def simdlen_clause(self, node: Tree) -> tree.Simdlen: + return self._simple_clause(tree.Simdlen, "length", node) + + # uniform_clause: UNIFORM_CLAUSE "(" [directive_name ":"] var_list ")" + def uniform_clause(self, node: Tree) -> tree.Uniform: + return self._simple_clause(tree.Uniform, "targets", node) + + # inbranch_clause: INBRANCH ["(" [directive_name ":"] py_expr ")"] + def inbranch_clause(self, node: Tree) -> tree.InBranch: + return self._simple_clause(tree.InBranch, "in_branch", node) + + # notinbranch_clause: NOTINBRANCH ["(" [directive_name ":"] py_expr ")"] + def notinbranch_clause(self, node: Tree) -> tree.NotInBranch: + return self._simple_clause(tree.NotInBranch, "not_in_branch", node) + + # enter_clause: ENTER_CLAUSE "(" [_enter_modifier_list ":"] var_list ")" + def enter_clause(self, node: Tree) -> tree.Enter: + return self._clause_with_mods( + tree.Enter, node.meta, node.children[0], node.children[1:-1], + targets=node.children[-1] + ) + + # indirect_clause: INDIRECT_CLAUSE ["(" [directive_name ":"] py_type ")"] + def indirect_clause(self, node: Tree) -> tree.Indirect: + return self._simple_clause(tree.Indirect, "invoked_by_fptr", node) + + # link_clause: LINK_CLAUSE "(" [directive_name ":"] var_list ")" + def link_clause(self, node: Tree) -> tree.Link: + return self._simple_clause(tree.Link, "targets", node) + + # local_clause: LOCAL_CLAUSE "(" [directive_name ":"] var_list ")" + def local_clause(self, node: Tree) -> tree.Local: + return self._simple_clause(tree.Local, "targets", node) + + # atomic_default_mem_order_clause: ATOMIC_DEFAULT_MEM_ORDER_CLAUSE "(" [directive_name ":"] (ACQ_REL | ACQUIRE | RELAXED | SEQ_CST) ")" + def atomic_default_mem_order_clause(self, node: Tree) -> tree.AtomicDefaultMemOrder: + return self._simple_clause(tree.AtomicDefaultMemOrder, "memory_order_name", node) + + # dynamic_allocators_clause: DYNAMIC_ALLOCATORS_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def dynamic_allocators_clause(self, node: Tree) -> tree.DynamicAllocators: + return self._simple_clause(tree.DynamicAllocators, "required", node) + + # reverse_offload_clause: REVERSE_OFFLOAD_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def reverse_offload_clause(self, node: Tree) -> tree.ReverseOffload: + return self._simple_clause(tree.ReverseOffload, "required", node) + + # unified_address_clause: UNIFIED_ADDRESS_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def unified_address_clause(self, node: Tree) -> tree.UnifiedAddress: + return self._simple_clause(tree.UnifiedAddress, "required", node) + + # unified_shared_memory_clause: UNIFIED_SHARED_MEMORY_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def unified_shared_memory_clause(self, node: Tree) -> tree.UnifiedSharedMemory: + return self._simple_clause(tree.UnifiedSharedMemory, "required", node) + + # self_maps_clause: SELF_MAPS_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def self_maps_clause(self, node: Tree) -> tree.SelfMaps: + return self._simple_clause(tree.SelfMaps, "required", node) + + # device_safesync_clause: DEVICE_SAFESYNC_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def device_safesync_clause(self, node: Tree) -> tree.DeviceSafesync: + return self._simple_clause(tree.DeviceSafesync, "required", node) + + # absent_clause: ABSENT_CLAUSE "(" [directive_name ":"] directive_list ")" + def absent_clause(self, node: Tree) -> tree.Absent: + return self._simple_clause(tree.Absent, "directive_names", node) + + # contains_clause: CONTAINS_CLAUSE "(" [directive_name ":"] directive_list ")" + def contains_clause(self, node: Tree) -> tree.Contains: + return self._simple_clause(tree.Contains, "directive_names", node) + + # holds_clause: HOLDS_CLAUSE "(" [directive_name ":"] py_expr ")" + def holds_clause(self, node: Tree) -> tree.Holds: + return self._simple_clause(tree.Holds, "hold_expr", node) + + # no_openmp_clause: NO_OPENMP_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def no_openmp_clause(self, node: Tree) -> tree.NoOpenmp: + return self._simple_clause(tree.NoOpenmp, "can_assume", node) + + # no_openmp_constructs_clause: NO_OPENMP_CONSTRUCTS_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def no_openmp_constructs_clause(self, node: Tree) -> tree.NoOpenmpConstructs: + return self._simple_clause(tree.NoOpenmpConstructs, "can_assume", node) + + # no_openmp_routines_clause: NO_OPENMP_ROUTINES_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def no_openmp_routines_clause(self, node: Tree) -> tree.NoOpenmpRoutines: + return self._simple_clause(tree.NoOpenmpRoutines, "can_assume", node) + + # no_parallelism_clause: NO_PARALLELISM_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def no_parallelism_clause(self, node: Tree) -> tree.NoParallelism: + return self._simple_clause(tree.NoParallelism, "can_assume", node) + + # at_clause: AT_CLAUSE "(" [directive_name ":"] (COMPILATION | EXECUTION) ")" + def at_clause(self, node: Tree) -> tree.At: + return self._simple_clause(tree.At, "action_time_name", node) + + # message_clause: MESSAGE_CLAUSE "(" [directive_name ":"] py_expr ")" + def message_clause(self, node: Tree) -> tree.Message: + return self._simple_clause(tree.Message, "msg_string", node) + + # severity_clause: SEVERITY_CLAUSE "(" [directive_name ":"] (FATAL | WARNING) ")" + def severity_clause(self, node: Tree) -> tree.Severity: + return self._simple_clause(tree.Severity, "severity_level_name", node) + + # looprange_clause: LOOPRANGE_CLAUSE "(" [directive_name ":"] py_expr "," py_expr ")" + @v_args(inline=True, meta=True) + def looprange_clause( + self, meta: Meta, token: Token, + directive_name: tree.DirectiveName|None, first: tree.PyExpr, count: tree.PyExpr, + ) -> tree.LoopRange: + return tree.LoopRange( + span = self.sv.meta2span(meta), + name = self._name_from_token(token), + first = first, + count = count, + directive_name = directive_name, + ) + + # permutation_clause: PERMUTATION_CLAUSE "(" [directive_name ":"] expr_list ")" + def permutation_clause(self, node: Tree) -> tree.Permutation: + return self._simple_clause(tree.Permutation, "permutation_list", node) + + # counts_clause: COUNTS_CLAUSE "(" [directive_name ":"] expr_list ")" + def counts_clause(self, node: Tree) -> tree.Counts: + return self._simple_clause(tree.Counts, "count_list", node) + + # sizes_clause: SIZES_CLAUSE "(" [directive_name ":"] expr_list ")" + def sizes_clause(self, node: Tree) -> tree.Sizes: + return self._simple_clause(tree.Sizes, "size_list", node) + + # full_clause: FULL_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def full_clause(self, node: Tree) -> tree.Full: + return self._simple_clause(tree.Full, "fully_unroll", node) + + # partial_clause: PARTIAL_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def partial_clause(self, node: Tree) -> tree.Partial: + return self._simple_clause(tree.Partial, "unroll_factor", node) + + # copyin_clause: COPYIN_CLAUSE "(" [directive_name ":"] var_list ")" + def copyin_clause(self, node: Tree) -> tree.CopyIn: + return self._simple_clause(tree.CopyIn, "targets", node) + + # num_threads_clause: NUM_THREADS_CLAUSE "(" [_num_threads_modifier_list ":"] expr_list ")" + def num_threads_clause(self, node: Tree) -> tree.NumThreads: + return self._clause_with_mods( + tree.NumThreads, node.meta, node.children[0], node.children[1:-1], + upper_bound=node.children[-1] + ) + + # proc_bind_clause: PROC_BIND_CLAUSE "(" [directive_name ":"] (CLOSE | PRIMARY | SPREAD) ")" + def proc_bind_clause(self, node: Tree) -> tree.ProcBind: + return self._simple_clause(tree.ProcBind, "affinity_policy_name", node) + + # safesync_clause: SAFESYNC_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def safesync_clause(self, node: Tree) -> tree.SafeSync: + return self._simple_clause(tree.SafeSync, "width", node) + + # num_teams_clause: NUM_TEAMS_CLAUSE "(" [_num_teams_modifier_list ":"] py_expr ")" + def num_teams_clause(self, node: Tree) -> tree.NumTeams: + return self._clause_with_mods( + tree.NumTeams, node.meta, node.children[0], node.children[1:-1], + upper_bound=node.children[-1] + ) + + # thread_limit_clause: THREAD_LIMIT_CLAUSE "(" [directive_name ":"] py_expr ")" + def thread_limit_clause(self, node: Tree) -> tree.ThreadLimit: + return self._simple_clause(tree.ThreadLimit, "threadlim", node) + + # nontemporal_clause: NONTEMPORAL_CLAUSE "(" [directive_name ":"] var_list ")" + def nontemporal_clause(self, node: Tree) -> tree.NonTemporal: + return self._simple_clause(tree.NonTemporal, "targets", node) + + # order_clause: ORDER_CLAUSE "(" [_order_modifier_list ":"] CONCURRENT ")" + def order_clause(self, node: Tree) -> tree.Order: + return self._clause_with_mods( + tree.Order, node.meta, node.children[0], node.children[1:-1], + ordering=self._name_from_token(node.children[-1]) + ) + + # safelen_clause: SAFELEN_CLAUSE "(" [directive_name ":"] py_expr ")" + def safelen_clause(self, node: Tree) -> tree.SafeLen: + return self._simple_clause(tree.SafeLen, "length", node) + + # filter_clause: FILTER_CLAUSE "(" [directive_name ":"] py_expr ")" + def filter_clause(self, node: Tree) -> tree.Filter: + return self._simple_clause(tree.Filter, "thread_num", node) + + # copyprivate_clause: COPYPRIVATE_CLAUSE "(" [directive_name ":"] var_list ")" + def copyprivate_clause(self, node: Tree) -> tree.CopyPrivate: + return self._simple_clause(tree.CopyPrivate, "targets", node) + + # ordered_clause: ORDERED_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def ordered_clause(self, node: Tree) -> tree.OrderedClause: + return self._simple_clause(tree.OrderedClause, "n", node) + + # schedule_clause: SCHEDULE_CLAUSE "(" [_schedule_modifier_list ":"] schedule_type ["," py_expr] ")" + def schedule_clause(self, node: Tree) -> tree.Schedule: + schedule_pos = -2 if isinstance(node.children[-1], tree.ScheduleType) else -1 + return self._clause_with_mods( + tree.Schedule, node.meta, node.children[0], node.children[1:schedule_pos], + type=node.children[schedule_pos], + chunk=node.children[-1] if schedule_pos == -2 else None, + ) + + # dist_schedule_clause: DIST_SCHEDULE_CLAUSE "(" [directive_name ":"] STATIC ["," py_expr] ")" + @v_args(inline=True, meta=True) + def dist_schedule_clause( + self, meta: Meta, token: Token, + directive_name: tree.DirectiveName|None, + static: Token, + chunk: tree.PyExpr|None, + ) -> tree.DistSchedule: + return tree.DistSchedule( + span = self.sv.meta2span(meta), + name = self._name_from_token(token), + static = self._name_from_token(static), + chunk_size = chunk, + directive_name = directive_name, + ) + + # bind_clause: BIND_CLAUSE "(" [directive_name ":"] _bind_clause_arg ")" + def bind_clause(self, node: Tree) -> tree.Bind: + return self._simple_clause(tree.Bind, "binding_name", node) + + # grainsize_clause: GRAINSIZE_CLAUSE "(" [_grainsize_modifier_list ":"] py_expr ")" + def grainsize_clause(self, node: Tree) -> tree.GrainSize: + return self._clause_with_mods( + tree.GrainSize, node.meta, node.children[0], node.children[1:-1], + grain_size=node.children[-1] + ) + + # num_tasks_clause: NUM_TASKS_CLAUSE "(" [_num_tasks_modifier_list ":"] py_expr ")" + def num_tasks_clause(self, node: Tree) -> tree.NumTasks: + return self._clause_with_mods( + tree.NumTasks, node.meta, node.children[0], node.children[1:-1], + grain_size=node.children[-1] + ) + + # graph_id_clause: GRAPH_ID_CLAUSE "(" [directive_name ":"] py_expr ")" + def graph_id_clause(self, node: Tree) -> tree.GraphId: + return self._simple_clause(tree.GraphId, "graph_id_value", node) + + # graph_reset_clause: GRAPH_RESET_CLAUSE "(" [directive_name ":"] py_expr ")" + def graph_reset_clause(self, node: Tree) -> tree.GraphReset: + return self._simple_clause(tree.GraphReset, "expr", node) + + # use_device_ptr_clause: USE_DEVICE_PTR_CLAUSE "(" [directive_name ":"] var_list ")" + def use_device_ptr_clause(self, node: Tree) -> tree.UseDevicePtr: + return self._simple_clause(tree.UseDevicePtr, "targets", node) + + # use_device_addr_clause: USE_DEVICE_ADDR_CLAUSE "(" [directive_name ":"] var_list ")" + def use_device_addr_clause(self, node: Tree) -> tree.UseDeviceAddr: + return self._simple_clause(tree.UseDeviceAddr, "targets", node) + + # defaultmap_clause: DEFAULTMAP_CLAUSE "(" _defaultmap_arg [":" _defaultmap_modifier_list] ")" + def defaultmap_clause(self, node: Tree) -> tree.DefaultMap: + return self._clause_with_mods( + tree.DefaultMap, node.meta, node.children[0], node.children[2:], + implicit_behavior_name=self._name_from_token(node.children[1]) + ) + + # uses_allocators_clause: USES_ALLOCATORS_CLAUSE "(" [_uses_allocator_modifier_list ":"] py_expr ")" + def uses_allocators_clause(self, node: Tree) -> tree.UsesAllocators: + return self._clause_with_mods( + tree.UsesAllocators, node.meta, node.children[0], node.children[1:-1], + grain_size=node.children[-1] + ) + + # to_clause: TO_CLAUSE "(" [_to_modifier_list ":"] var_list ")" + def to_clause(self, node: Tree) -> tree.To: + return self._clause_with_mods( + tree.To, node.meta, node.children[0], node.children[1:-1], + targets=node.children[-1] + ) + + # from_clause: FROM_CLAUSE "(" [_from_modifier_list ":"] var_list ")" + def from_clause(self, node: Tree) -> tree.From: + return self._clause_with_mods( + tree.From, node.meta, node.children[0], node.children[1:-1], + targets=node.children[-1] + ) + + # destroy_clause: DESTROY_CLAUSE "(" [directive_name ":"] IDENTIFIER ")" + def destroy_clause(self, node: Tree) -> tree.Destroy: + return self._simple_clause(tree.Destroy, "destroy_var", node) + + # init_clause: INIT_CLAUSE "(" [_init_modifier_list ":"] IDENTIFIER ")" + def init_clause(self, node: Tree) -> tree.Init: + span = self.sv.meta2span(node.meta) + kwargs: dict[str, tree.Construct|list[tree.Name]] = {} + for mod in node.children[1:-1]: + if mod is None: + continue + + # interop_type_modifier_name + if isinstance(mod, tree.Name): + if "interop_type_modifier_name" not in kwargs: + kwargs["interop_type_modifier_name"] = [mod] + else: + assert isinstance(kwargs["interop_type_modifier_name"], list) + kwargs["interop_type_modifier_name"].append(mod) # ty:ignore[invalid-argument-type] + + # prefer_type_modifier + if not isinstance(mod, tree.Prefer): + continue + + # depinfo_modifier + if not isinstance(mod, tree.DepInfo): + continue + + # directive_name_modifier + if not isinstance(mod, tree.DirectiveName): + continue + + if mod.id in kwargs: + raise self.sv.syntax_error( + f'"{mod.id}" modifier is already defined for init clause.', span, + diagnostics=[("first defined here", kwargs[mod.id].span)] # ty:ignore[unresolved-attribute] # zuban:ignore[union-attr] + ) + kwargs[mod.id] = mod # ty:ignore[invalid-assignment] # zuban:ignore[assignment] + + return tree.Init( + span = span, + name = self._name_from_token(node.children[0]), + init_var = cast("tree.PyName", node.children[-1]), + **kwargs # ty:ignore[invalid-argument-type] # zuban:ignore[arg-type] + ) + + # use_clause: USE_CLAUSE "(" [directive_name ":"] IDENTIFIER ")" + def use_clause(self, node: Tree) -> tree.Use: + return self._simple_clause(tree.Use, "interop_var", node) + + # hint_clause: HINT_CLAUSE "(" [directive_name ":"] py_expr ")" + def hint_clause(self, node: Tree) -> tree.Hint: + return self._simple_clause(tree.Hint, "expr", node) + + # task_reduction_clause: TASK_REDUCTION_CLAUSE "(" [directive_name ","] reduction_op ":" var_list ")" + def task_reduction_clause(self, node: Tree) -> tree.TaskReduction: + return tree.TaskReduction( + span=self.sv.meta2span(node.meta), + name=self._name_from_token(node.children[0]), + op = cast("tree.ReductionOp", node.children[-2]), + targets = cast("list[tree.PyName]", node.children[-1]), + directive_name = node.children[1] if isinstance(node.children[1], tree.DirectiveName) else None, + ) + + # memscope_clause: MEMSCOPE_CLAUSE "(" [directive_name ":"] (ALL | CGROUP | DEVICE) ")" + def memscope_clause(self, node: Tree) -> tree.MemScope: + return self._simple_clause(tree.MemScope, "scope_name", node) + + # read_clause: READ_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def read_clause(self, node: Tree) -> tree.Read: + return self._simple_clause(tree.Read, "", node) + + # atomic_update_clause: UPDATE_CLAUSE ["(" [directive_name ":"] py_expr ")"] // innermost-leaf, unique + def atomic_update_clause(self, node: Tree) -> tree.Update: + return self._simple_clause(tree.Update, "use_semantics", node) + + # write_clause: WRITE_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def write_clause(self, node: Tree) -> tree.Write: + return self._simple_clause(tree.Write, "use_semantics", node) + + # capture_clause: CAPTURE_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def capture_clause(self, node: Tree) -> tree.Capture: + return self._simple_clause(tree.Capture, "use_semantics", node) + + # compare_clause: COMPARE_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def compare_clause(self, node: Tree) -> tree.Compare: + return self._simple_clause(tree.Compare, "use_semantics", node) + + # fail_clause: FAIL_CLAUSE "(" [directive_name ":"] (ACQUIRE | RELAXED | SEQ_CST) ")" + def fail_clause(self, node: Tree) -> tree.Fail: + return self._simple_clause(tree.Fail, "mem_order_name", node) + + # weak_clause: WEAK_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def weak_clause(self, node: Tree) -> tree.Weak: + return self._simple_clause(tree.Weak, "use_semantics", node) + + # acq_rel_clause: ACQ_REL_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def acq_rel_clause(self, node: Tree) -> tree.AcqRel: + return self._simple_clause(tree.AcqRel, "use_semantics", node) + + # acquire_clause: ACQUIRE_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def acquire_clause(self, node: Tree) -> tree.Acquire: + return self._simple_clause(tree.Acquire, "use_semantics", node) + + # relaxed_clause: RELAXED_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def relaxed_clause(self, node: Tree) -> tree.Relaxed: + return self._simple_clause(tree.Relaxed, "use_semantics", node) + + # release_clause: RELEASE_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def release_clause(self, node: Tree) -> tree.Release: + return self._simple_clause(tree.Release, "use_semantics", node) + + # seq_cst_clause: SEQ_CST_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def seq_cst_clause(self, node: Tree) -> tree.SeqCst: + return self._simple_clause(tree.SeqCst, "use_semantics", node) + + # depobj_update_clause: UPDATE_CLAUSE "(" [_depobj_update_modifier_list ":"] IDENTIFIER ")" + def depobj_update_clause(self, node: Tree) -> tree.DepobjUpdate: + return self._clause_with_mods( + tree.DepobjUpdate, node.meta, node.children[0], node.children[1:-1], + update_var=node.children[-1] + ) + # doacross_clause: DOACROSS_CLAUSE "(" _doacross_modifier_list ":" _iterator_specifier ")" + def doacross_clause(self, node: Tree) -> tree.DoAcross: + return self._clause_with_mods( + tree.DoAcross, node.meta, node.children[0], node.children[1:-1], + targets=node.children[-1] + ) + + # threads_clause: THREADS_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def threads_clause(self, node: Tree) -> tree.Threads: + return self._simple_clause(tree.Threads, "appy_to_threads", node) + + # simd_clause: SIMD_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def simd_clause(self, node: Tree) -> tree.SimdClause: + return self._simple_clause(tree.SimdClause, "appy_to_simd", node) + + #### COMMON CLAUSES ######################################################## + + # apply_clause: APPLY_CLAUSE "(" [_apply_modifier_list ":"] apply_clause_arg ")" + def apply_clause(self, node: Tree) -> tree.Apply: + return self._clause_with_mods( + tree.Apply, node.meta, node.children[0], node.children[1:-1], + directives=[self._name_from_token(t) for t in node.children[-1].children] + ) + + # depend_clause: DEPEND_CLAUSE "(" [_depend_modifier_list ":"] expr_list ")" + def depend_clause(self, node: Tree) -> tree.Depend: + return self._clause_with_mods( + tree.Depend, node.meta, node.children[0], node.children[1:-1], + locator_list=node.children[-1] + ) + + # device_clause: DEVICE_CLAUSE "(" [_device_modifier_list ":"] py_expr ")" + def device_clause(self, node: Tree) -> tree.Device: + return self._clause_with_mods( + tree.Device, node.meta, node.children[0], node.children[1:-1], + directive=node.children[-1] + ) + + # default_clause: DEFAULT_CLAUSE "(" (NONE | SHARED | FIRSTPRIVATE | PRIVATE) [":" _default_modifier] ")" + def default_clause(self, node: Tree) -> tree.When: + return self._clause_with_mods( + tree.When, node.meta, node.children[0], node.children[2:], + data_sharing_attr_name=self._name_from_token(node.children[1]), + ) + + # private_clause: PRIVATE_CLAUSE "(" [directive_name ":"] var_list ")" + def private_clause(self, node: Tree) -> tree.Private: + return self._simple_clause(tree.Private, "targets", node) + + # if_clause: IF_CLAUSE "(" [directive_name ":"] py_expr ")" + def if_clause(self, node: Tree) -> tree.If: + return self._simple_clause(tree.If, "expr", node) + + # firstprivate_clause: FIRSTPRIVATE_CLAUSE "(" [_firstprivate_modifier ":"] var_list ")" + def firstprivate_clause(self, node: Tree) -> tree.FirstPrivate: + return self._clause_with_mods( + tree.FirstPrivate, node.meta, node.children[0], node.children[1:-1], + targets=node.children[-1] + ) + + # reduction_clause: REDUCTION_CLAUSE "(" [_reduction_modifier_list ","] reduction_op ":" var_list ")" + def reduction_clause(self, node: Tree) -> tree.Reduction: + return self._clause_with_mods( + tree.Reduction, node.meta, node.children[0], node.children[1:-2], + targets=node.children[-1], + op=node.children[-2], + ) + + # induction_clause: INDUCTION_CLAUSE "(" _induction_modifier_list "," induction_op ":" var_list ")" + def induction_clause(self, node: Tree) -> tree.Induction: + return self._clause_with_mods( + tree.Induction, node.meta, node.children[0], node.children[1:-2], + targets=node.children[-1], + op=node.children[-2], + ) + + # shared_clause: SHARED_CLAUSE "(" [directive_name ":"] var_list ")" + def shared_clause(self, node: Tree) -> tree.Shared: + return self._simple_clause(tree.Shared, "targets", node) + + # collapse_clause: COLLAPSE_CLAUSE "(" [directive_name ":"] py_expr ")" + def collapse_clause(self, node: Tree) -> tree.Collapse: + return self._simple_clause(tree.Collapse, "num", node) + + # lastprivate_clause: LASTPRIVATE_CLAUSE "(" [_lastprivate_modifier_list ":"] var_list ")" + def lastprivate_clause(self, node: Tree) -> tree.LastPrivate: + return self._clause_with_mods( + tree.LastPrivate, node.meta, node.children[0], node.children[1:-1], + targets=node.children[-1] + ) + + # allocate_clause: ALLOCATE_CLAUSE "(" [_allocate_modifier_list ":"] var_list ")" + def allocate_clause(self, node: Tree) -> tree.AllocateClause: + return self._clause_with_mods( + tree.AllocateClause, node.meta, node.children[0], node.children[1:-1], + targets=node.children[-1] + ) + + # nowait_clause: NOWAIT_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def nowait_clause(self, node: Tree) -> tree.NoWait: + return self._simple_clause(tree.NoWait, "dont_synchronize", node) + + # final_clause: FINAL_CLAUSE "(" [directive_name ":"] py_expr ")" + def final_clause(self, node: Tree) -> tree.Final: + return self._simple_clause(tree.Final, "finalize", node) + + # mergeable_clause: MERGEABLE_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def mergeable_clause(self, node: Tree) -> tree.Mergeable: + return self._simple_clause(tree.Mergeable, "can_merge", node) + + # untied_clause: UNTIED_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def untied_clause(self, node: Tree) -> tree.Untied: + return self._simple_clause(tree.Untied, "can_change_threads", node) + + # affinity_clause: AFFINITY_CLAUSE "(" [_affinity_modifier_list ":"] var_list ")" + def affinity_clause(self, node: Tree) -> tree.When: + return self._clause_with_mods( + tree.When, node.meta, node.children[0], node.children[1:-1], + targets=node.children[-1] + ) + + # detach_clause: DETACH_CLAUSE "(" [directive_name ":"] IDENTIFIER ")" + def detach_clause(self, node: Tree) -> tree.Detach: + return self._simple_clause(tree.Detach, "event_handle", node) + + # in_reduction_clause: IN_REDUCTION_CLAUSE "(" [directive_name ","] reduction_op ":" var_list ")" + def in_reduction_clause(self, node: Tree) -> tree.InReduction: + return self._clause_with_mods( + tree.InReduction, node.meta, node.children[0], node.children[1:-2], + targets=node.children[-1], + op=node.children[-2], + ) + + # priority_clause: PRIORITY_CLAUSE "(" [directive_name ":"] py_expr ")" + def priority_clause(self, node: Tree) -> tree.Priority: + return self._simple_clause(tree.Priority, "value", node) + + # replayable_clause: REPLAYABLE_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def replayable_clause(self, node: Tree) -> tree.Replayable: + return self._simple_clause(tree.Replayable, "expr", node) + + # threadset_clause: THREADSET_CLAUSE "(" [directive_name ":"] (OMP_TEAM | OMP_POOL) ")" + def threadset_clause(self, node: Tree) -> tree.ThreadSet: + return self._simple_clause(tree.ThreadSet, "set_name", node) + + # transparent_clause: TRANSPARENT_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def transparent_clause(self, node: Tree) -> tree.Transparent: + return self._simple_clause(tree.Transparent, "impex_type", node) + + # nogroup_clause: NOGROUP_CLAUSE ["(" [directive_name ":"] py_expr ")"] + def nogroup_clause(self, node: Tree) -> tree.NoGroup: + return self._simple_clause(tree.NoGroup, "dont_synchronize", node) + + # map_clause: MAP_CLAUSE "(" [[_map_modifier_list ","] map_type_name ":"] var_list ")" + def map_clause(self, node: Tree) -> tree.Map: + return self._clause_with_mods( + tree.Map, node.meta, node.children[0], node.children[1:-1], + targets=node.children[-1] + ) + + #### SPECIAL CASE CONSTRUCTS ############################################### + + # THREADPRIVATE "(" var_list ")" + @v_args(inline=True, meta=True) + def threadprivate_directive(self, meta: Meta, token: Token, targets: list[tree.PyName]) -> tree.ThreadPrivate: + return self._construct(meta, token, [], targets=targets) + + # DECLARE_REDUCTION_DIRECTIVE "(" reduction_op ":" expr_list ")" _declare_reduction_clause_list + @v_args(inline=True, meta=True) + def declare_reduction_directive6( + self, meta: Meta, token: Token, + op: tree.ReductionOp, expr_list: list[tree.PyExpr], + *clause_list: tree.Clause, + ) -> tree.DeclareReduction: + return self._construct(meta, token, clause_list, op=op, ann_list=expr_list) + + # DECLARE_REDUCTION_DIRECTIVE "(" reduction_op ":" expr_list ":" py_stmt ")" initializer_clause? + @v_args(inline=True, meta=True) + def declare_reduction_directive( + self, meta: Meta, token: Token, + op: tree.ReductionOp, type_list: list[tree.PyExpr], py_stmt: tree.PyStmt, + initializer: tree.Initializer|None=None + ) -> tree.DeclareReduction: + span = self.sv.meta2span(meta) + name = self._name_from_token(token) + return tree.DeclareReduction( + span = span, + name = name, + op = op, + ann_list = type_list, + combiner = tree.Combiner(span=span, name=name, combiner_stmt=py_stmt), + initializer = initializer, + ) + + # DECLARE_INDUCTION_DIRECTIVE "(" induction_op ":" expr_list ")" _declare_induction_clause_list + @v_args(inline=True, meta=True) + def declare_induction_directive( + self, meta: Meta, token: Token, + op: tree.InductionOp, expr_list: list[tree.PyExpr], + *clause_list: tree.Clause, + ) -> tree.DeclareInduction: + return self._construct(meta, token, clause_list, op=op, ann_list=expr_list) + + # DECLARE_MAPPER_DIRECTIVE "(" [IDENTIFIER ":"] IDENTIFIER ":" py_type ")" map_clause+ + def declare_mapper_directive(self, node: Tree) -> tree.DeclareMapper: + token, *rest = node.children + split = next((i for i, c in enumerate(rest) if isinstance(c, tree.Clause)), len(rest)) + fixed, clause_list = rest[:split], rest[split:] + + if len(fixed) == 3: + mapper, var, type_ = fixed + else: + mapper = None + var, type_ = fixed + + return self._construct(node.meta, token, clause_list, mapper_identifier=mapper, var=var, type=type_) # ty: ignore [invalid-argument-type] # zuban: ignore[arg-type] + + # ALLOCATE_DIRECTIVE "(" var_list ")" _allocate_clause_list? + @v_args(inline=True, meta=True) + def allocate_directive( + self, meta: Meta, token: Token, + var_list: list[tree.PyName], + *clause_list: tree.Clause, + ) -> tree.DeclareMapper: + return self._construct(meta, token, clause_list, targets=var_list) + + # DECLARE_VARIANT_DIRECTIVE "(" [py_expr ":"] py_expr ")" _declare_variant_clause_list + def declare_variant_directive(self, node: Tree) -> tree.DeclareMapper: + token, *rest = node.children + split = next((i for i, c in enumerate(rest) if isinstance(c, tree.Clause)), len(rest)) + fixed, clause_list = rest[:split], rest[split:] + + if len(fixed) == 2: + base_name, variant_name = fixed + else: + base_name = None + (variant_name,) = fixed + + return self._construct(node.meta, token, clause_list, base_name=base_name, variant_name=variant_name) # ty: ignore [invalid-argument-type] # zuban: ignore[arg-type] + + # DECLARE_SIMD_DIRECTIVE ["(" py_expr ")"] _declare_simd_clause_list? + def declare_simd_directive(self, node: Tree) -> tree.DeclareMapper: + token, *rest = node.children + split = next((i for i, c in enumerate(rest) if isinstance(c, tree.Clause)), len(rest)) + fixed, clause_list = rest[:split], rest[split:] + + proc_name = fixed[0] if fixed else None + + return self._construct(node.meta, token, clause_list, proc_name=proc_name) # ty: ignore [invalid-argument-type] # zuban: ignore[arg-type] + + # DECLARE_TARGET_DIRECTIVE "(" var_list ")" -> declare_target_directive + @v_args(inline=True, meta=True) + def declare_target_directive( + self, meta: Meta, token: Token, var_list: list[tree.PyName] + ) -> tree.DeclareMapper: + return self._construct(meta, token, [], targets=var_list) + + # CRITICAL_DIRECTIVE ["(" IDENTIFIER ")" [","? hint_clause]] + def critical_directive(self, node: Tree) -> tree.Critical: + token, *rest = node.children + + if len(rest) == 0: + name, hint = None, None + elif len(rest) == 1: + name, hint = rest[0], None + else: + name, hint = rest + + return self._construct(node.meta, token, [hint] if hint is not None else [], critical_name=name) # ty: ignore [invalid-argument-type] # zuban: ignore + + # FLUSH_DIRECTIVE [acq_rel_clause | acquire_clause | ...] ["(" var_list ")"] + def flush_directive(self, node: Tree) -> tree.Flush: + token, *rest = node.children + + clause = next((c for c in rest if isinstance(c, tree.Clause)), None) + var_list = next((c for c in rest if not isinstance(c, tree.Clause)), None) + + return self._construct(node.meta, token, [clause] if clause is not None else [], targets=var_list) # ty: ignore [invalid-argument-type] # zuban: ignore[arg-type] + + # DEPOBJ_DIRECTIVE "(" IDENTIFIER ")" (destroy_clause | init_clause | depobj_update_clause) + @v_args(inline=True, meta=True) + def depobj_directive( + self, meta: Meta, token: Token, + object: tree.PyName, clause: tree.Clause + ) -> tree.Depobj: + return self._construct(meta, token, [clause], object=object) + + # CANCEL_DIRECTIVE [directive_name ":"] construct_type_clause [","? if_clause] + def cancel_directive(self, node: Tree) -> tree.Cancel: + # TODO: ignoring directive_name here + if_clause = node.children[-1] if isinstance(node.children[-1], tree.If) else None + construct_type = node.children[-1 if if_clause is None else -2] + return tree.Cancel( + span=self.sv.meta2span(node.meta), + name=self._name_from_token(node.children[0]), + construct_type_name=self._name_from_token(construct_type), + if_=if_clause, + ) + + # CANCELLATION_POINT_DIRECTIVE [directive_name ":"] construct_type_clause + def cancellation_point_directive(self, node: Tree) -> tree.CancellationPoint: + # TODO: ignoring directive_name here + return tree.CancellationPoint( + span=self.sv.meta2span(node.meta), + name=self._name_from_token(node.children[0]), + construct_type_name=self._name_from_token(node.children[-1]), + ) + + ############################################################################ + + # combined_directive: combined_directive_name combined_directive_name+ [combined_clause_list] + def combined_directive(self, node: Tree) -> tree.Directive: + span = self.sv.meta2span(node.meta) + if isinstance(node.children[-1], Tree): + clause_list = cast("list[tree.Clause]", node.children[-1].children) + directive_list = node.children[:-1] + else: + clause_list = [] + directive_list = node.children + + constructs = {} + for directive_token in directive_list: + directive_token = cast("Token", directive_token) + r: tuple[tree.Construct, list[tree.Clause]] = self._construct_with_rejected(node.meta, directive_token, clause_list) + if r[0].id in constructs: + raise self.sv.syntax_error( + f"{r[0].id} directive appears more than once.", + r[0].name.span, + diagnostics=[("first defined here.", constructs[r[0].id].name.span)] + ) + constructs[r[0].id] = r[0] + clause_list = r[1] + + if clause_list: + raise self.sv.syntax_error( + f"some clauses were not used in this combined construct.", + span, + diagnostics=[ + (f"{clause.id} clause was not used.", clause.span) + for clause in clause_list + ] + ) + + return tree.Directive( + span = span, + string = self.sv.source_text(self.sv.span), # NOTE: this includes the quotes + constructs = constructs, + ) + + @v_args(inline=True) + def start(self, directive: Tree|tree.Directive) -> tree.Directive: + # If it was already transformed, just return that + if isinstance(directive, tree.Directive): + return directive + + if isinstance(directive, tree.Construct): + span = directive.span + construct = directive + + if isinstance(directive, Tree): + # Otherwise, assuming this rule format, process the directive in a general case: + # task_directive: TASK_DIRECTIVE _task_clause_list? + span = self.sv.meta2span(directive.meta) + directive_token = cast("Token", directive.children[0]) + clause_list = cast("list[tree.Clause]", directive.children[1:]) + construct = self._construct(directive.meta, directive_token, clause_list) + + return tree.Directive( + span = span, + string = self.sv.source_text(self.sv.span), # NOTE: this includes the quotes + constructs = {construct.id: construct}, + ) diff --git a/omp4py/core/parser/tree.py b/omp4py/core/parser/tree.py index a981827..a3190b8 100644 --- a/omp4py/core/parser/tree.py +++ b/omp4py/core/parser/tree.py @@ -7,57 +7,71 @@ """ from __future__ import annotations +from omp4py.runtime.icvs import defaults +from Cython.Compiler.Options import CompilationOptions -from ast import alias, arg, expr, keyword, pattern, stmt, type_param from dataclasses import dataclass, field from enum import Enum -from typing import ClassVar +from typing import TYPE_CHECKING, ClassVar + +if TYPE_CHECKING: + from ast import alias, arg, expr, keyword, pattern, stmt, type_param __all__ = [ - "Barrier", - "Clause", - "Collapse", - "Combiner", + # Base + "Span", + "OmpNode", + "Name", + "Directive", "Construct", - "CopyIn", - "CopyPrivate", - "Critical", + "Clause", "DataScope", - "DeclareReduction", - "Default", - "Directive", - "FirstPrivate", - "For", - "If", - "Initializer", - "LastPrivate", - "Master", "Modifier", - "Name", - "NoWait", - "NumThreads", - "OmpNode", - "Ordered", - "OrderedClause", - "Parallel", - "ParallelFor", - "ParallelSections", - "Private", - "ProcBind", - "PyExpr", - "PyInt", - "PyName", - "PyStmt", - "Reduction", - "ReductionOp", - "Schedule", + # Constructs + "ThreadPrivate", "DeclareReduction", "DeclareInduction", "Scan", "DeclareMapper", "GroupPrivate", + "Allocate", + "Metadirective", "DeclareVariant", "Dispatch", "DeclareSimd", "DeclareTarget", + "Requires", "Assume", "Nothing", "Error", + "Fuse", "Interchange", "Reverse", "Split", "Stripe", "Tile", "Unroll", + "Parallel", "Teams", "Simd", "Masked", + "Single", "Scope", "Sections", "Section", "Workshare", "Workdistribute", "For", "Distribute", "Loop", + "Task", "Taskloop", "TaskIteration", "Taskyield", "Taskgraph", + "TargetData", "TargetEnterData", "TargetExitData", "Target", "TargetUpdate", + "InteropConstruct", + "Critical", "Barrier", "Taskgroup", "Taskwait", "Atomic", "Flush", "Depobj", "Ordered", + "Cancel", "CancellationPoint", + # Clauses + "Combiner", "Initializer", "Inductor", "Collector", + "Exclusive", "Inclusive", "InitComplete", + "DeviceType", + "Align", "Allocator", "When", "Otherwise", + "AdjustArgs", "AppendArgs", "Match", + "InteropClause", + "IsDevicePtr", "HasDeviceAddr", "NoContext", "NoVariants", + "Aligned", "Linear", "Simdlen", "Uniform", "InBranch", "NotInBranch", + "Enter", "Indirect", "Link", "Local", + "AtomicDefaultMemOrder", "DynamicAllocators", "ReverseOffload", "UnifiedAddress", "UnifiedSharedMemory", "SelfMaps", "DeviceSafesync", + "Absent", "Contains", "Holds", "NoOpenmp", "NoOpenmpConstructs", "NoOpenmpRoutines", "NoParallelism", + "At", "Message", "Severity", + "LoopRange", "Permutation", "Counts", "Sizes", "Full", "Partial", + "CopyIn", "NumThreads", "ProcBind", "SafeSync", "NumTeams", + "ThreadLimit", "NonTemporal", "Order", "SafeLen", "Filter", + "CopyPrivate", "OrderedClause", "Schedule", "DistSchedule", + "Bind", "GrainSize", "NumTasks", "GraphId", "GraphReset", "UseDevicePtr", "UseDeviceAddr", + "DefaultMap", "UsesAllocators", "From", "To", + "Destroy", "Init", "Use", + "Hint", "TaskReduction", "MemScope", + "Read", "Update", "Write", "Capture", "Compare", "Fail", "Weak", "AcqRel", "Acquire", "Relaxed", "Release", "SeqCst", "DepobjUpdate", "DoAcross", "SimdClause", "Threads", + "Apply", "Depend", "Device", "Default", + "Private", "If", "FirstPrivate", "Reduction", "Induction", "Shared", "Collapse", "LastPrivate", "AllocateClause", "NoWait", + "Final", "Mergeable", "Untied", "Affinity", "Detach", "InReduction", "Priority", "Replayable", "ThreadSet", "Transparent", "NoGroup", "Map", + # Modifiers + "DirectiveName", "ScheduleType", - "Section", - "Sections", - "Shared", - "Single", - "Span", - "ThreadPrivate", + "ReductionOp", "InductionOp", + "Original", "InteropModifier", "Iterator", "Step", "AllocatorModifier", "AlignModifier", + "Mapper", "MemSpace", "Traits", "DepInfo", "LoopModifier", "Prefer", "ContextSelector", + "PyExpr", "PyInt", "PyName", "PyStmt", ] @@ -103,301 +117,1989 @@ def __str__(self): return self.string +#### DIRECTIVES & CONSTRUCTS #### + @dataclass class Directive(OmpNode): string: str - construct: Construct - - -####################################################################################################################### -##################################################### Constructs ###################################################### -####################################################################################################################### + # Dict[directive_name, Construct] to model combined constructs. + # In OpenMP 6.0 there is 413 different combined constructs, + # it doesn't make sense to create a class for each of them. + constructs: dict[str, Construct] @dataclass class Construct(OmpNode): + id: ClassVar[str] = "construct" # must be redefined + name: Name + + +#### CLAUSES #### + +@dataclass(kw_only=True) +class Clause(OmpNode): + id: ClassVar[str] = "clause" # must be redefined + directive_name: DirectiveName|None = None name: Name @dataclass -class Barrier(Construct): - pass +class DataScope(Clause): + targets: list[PyName] + + @property + def str_targets(self) -> list[str]: + return [v.string for v in self.targets] +#### MODIFIERS #### + @dataclass -class Critical(Construct): - pass +class Modifier(OmpNode): + id: ClassVar[str] = "modifier" # must be redefined + + +@dataclass +class DirectiveName(Modifier): + id: ClassVar[str] = "directive_name" + string: str + + def __str__(self): + return self.string + + +####################################################################################################################### +##################################################### Constructs ###################################################### +####################################################################################################################### + + +#### DATA ENVIRONMENT DIRECTIVES #### + +@dataclass +class ThreadPrivate(Construct): + id: ClassVar[str] = "threadprivate" + targets: list[PyName] = field(default_factory=list) + + @property + def str_targets(self) -> list[str]: + return [v.string for v in self.targets] @dataclass class DeclareReduction(Construct): - id: ReductionOp + id: ClassVar[str] = "declare_reduction" + op: ReductionOp ann_list: list[PyExpr] combiner: Combiner initializer: Initializer | None = None @dataclass -class For(Construct): - collapse: Collapse | None = None - first_private: list[FirstPrivate] = field(default_factory=list) - last_private: list[LastPrivate] = field(default_factory=list) - no_wait: NoWait | None = None - ordered: OrderedClause | None = None - private: list[Private] = field(default_factory=list) - reduction: list[Reduction] = field(default_factory=list) - schedule: Schedule | None = None +class DeclareInduction(Construct): + id: ClassVar[str] = "declare_induction" + op: InductionOp + ann_list: list[PyExpr] + collector: Collector + inductor: Inductor @dataclass -class Master(Construct): - pass +class Scan(Construct): + id: ClassVar[str] = "scan" + exclusive: Exclusive|None = None + inclusive: Inclusive|None = None + init_complete: InitComplete|None = None + + +@dataclass(kw_only=True) +class DeclareMapper(Construct): + id: ClassVar[str] = "declare_mapper" + mapper_identifier: PyName|None = None + var: PyName + type: PyExpr + map: list[Map] = field(default_factory=list) @dataclass -class Ordered(Construct): - pass +class GroupPrivate(Construct): + id: ClassVar[str] = "groupprivate" + device_type: DeviceType|None = None +#### MEMORY MANAGEMENT DIRECTIVES #### + @dataclass -class Parallel(Construct): - copyin: list[CopyIn] = field(default_factory=list) - default: Default | None = None - first_private: list[FirstPrivate] = field(default_factory=list) - if_: If | None = None - num_threads: NumThreads | None = None - private: list[Private] = field(default_factory=list) - proc_bind: ProcBind | None = None - reduction: list[Reduction] = field(default_factory=list) - shared: list[Shared] = field(default_factory=list) +class Allocate(Construct): + id: ClassVar[str] = "allocate" + targets: list[PyName] = field(default_factory=list) + + align: Align|None = None + allocator: Allocator|None = None + + @property + def str_targets(self) -> list[str]: + return [v.string for v in self.targets] + +#### VARIANT DIRECTIVES #### @dataclass -class Section(Construct): - pass +class Metadirective(Construct): + id: ClassVar[str] = "metadirective" + when: list[When] = field(default_factory=list) + otherwise: Otherwise|None = None + + +@dataclass(kw_only=True) +class DeclareVariant(Construct): + id: ClassVar[str] = "declare_variant" + base_name: PyExpr|None = None + variant_name: PyExpr + + adjust_args: list[AdjustArgs] = field(default_factory=list) + append_args: AppendArgs|None = None + match: Match @dataclass -class Sections(Construct): - first_private: list[FirstPrivate] = field(default_factory=list) - last_private: list[LastPrivate] = field(default_factory=list) - no_wait: NoWait | None = None - private: list[Private] = field(default_factory=list) - reduction: list[Reduction] = field(default_factory=list) +class Dispatch(Construct): + id: ClassVar[str] = "dispatch" + depend: list[Depend] = field(default_factory=list) + device: Device|None = None + interop: list[InteropClause] = field(default_factory=list) + is_device_ptr: list[IsDevicePtr] = field(default_factory=list) + has_device_addr: list[HasDeviceAddr] = field(default_factory=list) + no_context: NoContext|None = None + no_variants: NoVariants|None = None + no_wait: NoWait|None = None + @dataclass -class Single(Construct): - first_private: list[FirstPrivate] = field(default_factory=list) - no_wait: NoWait | None = None - private: list[Private] = field(default_factory=list) - copyprivate: list[CopyPrivate] = field(default_factory=list) +class DeclareSimd(Construct): + id: ClassVar[str] = "declare_simd" + proc_name: PyExpr|None = None + + aligned: list[Aligned] = field(default_factory=list) + linear: list[Linear] = field(default_factory=list) + simdlen: Simdlen|None = None + uniform: list[Uniform] = field(default_factory=list) + # TODO: InBranch and NotInBranch are exclusive + in_branch: InBranch|None = None + not_in_branch: NotInBranch|None = None @dataclass -class ThreadPrivate(Construct): - targets: list[PyName] +class DeclareTarget(Construct): + id: ClassVar[str] = "declare_target" + targets: list[PyName]|None = None + + device_type: DeviceType|None = None + enter: list[Enter] = field(default_factory=list) + indirect: Indirect|None = None + link: list[Link] = field(default_factory=list) + local: list[Local] = field(default_factory=list) @property def str_targets(self) -> list[str]: - return [v.string for v in self.targets] + return [v.string for v in self.targets or []] -####################################################################################################################### -################################################# Combined Constructs ################################################# -####################################################################################################################### +#### INFORMATIONAL AND UTILITY DIRECTIVES #### + +@dataclass +class Requires(Construct): + id: ClassVar[str] = "requires" + atomic_default_mem_order: AtomicDefaultMemOrder|None = None + dynamic_allocators: DynamicAllocators|None = None + reverse_offload: ReverseOffload|None = None + unified_address: UnifiedAddress|None = None + unified_shared_memory: UnifiedSharedMemory|None = None + self_maps: SelfMaps|None = None + device_safesync: DeviceSafesync|None = None @dataclass -class ParallelFor(Construct): - parallel: Parallel - for_: For +class Assume(Construct): + id: ClassVar[str] = "assume" + absent: Absent|None = None + contains: Contains|None = None + holds: Holds|None = None + no_openmp: NoOpenmp|None = None + no_openmop_contructs: NoOpenmpConstructs|None = None + no_openmp_routines: NoOpenmpRoutines|None = None + no_parallelism: NoParallelism|None = None @dataclass -class ParallelSections(Construct): - parallel: Parallel - sections: Sections +class Nothing(Construct): + id: ClassVar[str] = "nothing" + apply: list[Apply] = field(default_factory=list) -####################################################################################################################### -####################################################### Clauses ####################################################### -####################################################################################################################### +@dataclass +class Error(Construct): + id: ClassVar[str] = "error" + at: At|None = None + message: Message|None = None + severity: Severity|None = None + +#### LOOP TRANSFORMING CONSTRUCTS #### @dataclass -class Clause(OmpNode): - id: ClassVar[str] = "clause" # must be redefined - name: Name +class Fuse(Construct): + id: ClassVar[str] = "fuse" + apply: Apply|None = None + looprange: LoopRange|None = None @dataclass -class DataScope(Clause): - targets: list[PyName] +class Interchange(Construct): + id: ClassVar[str] = "interchange" + apply: Apply|None = None + permutation: Permutation|None = None - @property - def str_targets(self) -> list[str]: - return [v.string for v in self.targets] + +@dataclass +class Reverse(Construct): + id: ClassVar[str] = "reverse" + apply: Apply|None = None + + +@dataclass(kw_only=True) +class Split(Construct): + id: ClassVar[str] = "split" + apply: Apply|None = None + counts: Counts + + +@dataclass(kw_only=True) +class Stripe(Construct): + id: ClassVar[str] = "stripe" + apply: list[Apply] = field(default_factory=list) + sizes: Sizes + + +@dataclass(kw_only=True) +class Tile(Construct): + id: ClassVar[str] = "tile" + apply: Apply|None = None + sizes: Sizes @dataclass -class Collapse(Clause): - id: ClassVar[str] = "collapse" - num: PyInt +class Unroll(Construct): + id: ClassVar[str] = "unroll" + apply: Apply|None = None + full: Full|None = None + partial: Partial|None = None + +#### PARALLELISM CONSTRUCTS #### @dataclass -class Combiner(Clause): - id: ClassVar[str] = "combiner" - stmt: PyStmt +class Parallel(Construct): + id: ClassVar[str] = "parallel" + allocate: list[AllocateClause] = field(default_factory=list) + copyin: list[CopyIn] = field(default_factory=list) + default: Default|None = None + first_private: list[FirstPrivate] = field(default_factory=list) + if_: If|None = None + message: Message|None = None + num_threads: NumThreads | None = None + private: list[Private] = field(default_factory=list) + proc_bind: ProcBind|None = None + reduction: list[Reduction] = field(default_factory=list) + safesync: SafeSync|None = None + severity: Severity|None = None + shared: list[Shared] = field(default_factory=list) @dataclass -class CopyIn(DataScope): - id: ClassVar[str] = "copyin" +class Teams(Construct): + id: ClassVar[str] = "teams" + allocate: list[AllocateClause] = field(default_factory=list) + default: Default|None = None + first_private: list[FirstPrivate] = field(default_factory=list) + if_: If|None = None + num_teams: NumTeams|None = None + reduction: list[Reduction] = field(default_factory=list) + shared: list[Shared] = field(default_factory=list) + thread_limit: ThreadLimit|None = None @dataclass -class CopyPrivate(DataScope): - id: ClassVar[str] = "copyprivate" +class Simd(Construct): + id: ClassVar[str] = "simd" + aligned: list[Aligned] = field(default_factory=list) + collapse: Collapse|None = None + if_: If|None = None + induction: list[Induction] = field(default_factory=list) + last_private: list[LastPrivate] = field(default_factory=list) + linear: list[Linear] = field(default_factory=list) + non_temporal: list[NonTemporal] = field(default_factory=list) + order: Order|None = None + private: list[Private] = field(default_factory=list) + reduction: list[Reduction] = field(default_factory=list) + safelen: SafeLen|None = None + simdlen: Simdlen|None = None @dataclass -class Default(Clause): - id: ClassVar[str] = "default" - ntype: Name +class Masked(Construct): + id: ClassVar[str] = "masked" + filter: Filter|None = None - class Type(Enum): - SHARED = 0 - FIRST_PRIVATE = 1 - PRIVATE = 2 - NONE = 3 - type: Type = field(init=False) +#### WORKSHARING CONTRUCTS #### - def __post_init__(self) -> None: - object.__setattr__( - self, - "type", - { - "shared": self.Type.SHARED, - "firstprivate": self.Type.FIRST_PRIVATE, - "private": self.Type.PRIVATE, - "none": self.Type.NONE, - }[self.ntype.string.lower()], - ) +@dataclass +class Single(Construct): + id: ClassVar[str] = "single" + # TODO: CopyPrivate and NoWait are exclusive + allocate: list[AllocateClause] = field(default_factory=list) + copyprivate: list[CopyPrivate] = field(default_factory=list) + first_private: list[FirstPrivate] = field(default_factory=list) + no_wait: NoWait | None = None + private: list[Private] = field(default_factory=list) @dataclass -class FirstPrivate(DataScope): - id: ClassVar[str] = "first_private" +class Scope(Construct): + id: ClassVar[str] = "scope" + allocate: list[AllocateClause] = field(default_factory=list) + first_private: list[FirstPrivate] = field(default_factory=list) + no_wait: NoWait | None = None + private: list[Private] = field(default_factory=list) + reduction: list[Reduction] = field(default_factory=list) @dataclass -class If(Clause): - id: ClassVar[str] = "if_" - expr: PyExpr +class Sections(Construct): + id: ClassVar[str] = "sections" + allocate: list[AllocateClause] = field(default_factory=list) + first_private: list[FirstPrivate] = field(default_factory=list) + last_private: list[LastPrivate] = field(default_factory=list) + no_wait: NoWait | None = None + private: list[Private] = field(default_factory=list) + reduction: list[Reduction] = field(default_factory=list) + +@dataclass +class Section(Construct): + id: ClassVar[str] = "section" @dataclass -class Initializer(Clause): - id: ClassVar[str] = "initializer" - stmt: PyStmt +class Workshare(Construct): + id: ClassVar[str] = "workshare" + no_wait: NoWait | None = None @dataclass -class LastPrivate(DataScope): - id: ClassVar[str] = "last_private" +class Workdistribute(Construct): + id: ClassVar[str] = "workdistribute" @dataclass -class NoWait(Clause): - id: ClassVar[str] = "no_wait" - expr: PyExpr | None +class For(Construct): + id: ClassVar[str] = "for" + allocate: list[AllocateClause] = field(default_factory=list) + collapse: Collapse|None = None + first_private: list[FirstPrivate] = field(default_factory=list) + induction: list[Induction] = field(default_factory=list) + last_private: list[LastPrivate] = field(default_factory=list) + linear: list[Linear] = field(default_factory=list) + no_wait: NoWait|None = None + order: Order|None = None + ordered: OrderedClause|None = None + private: list[Private] = field(default_factory=list) + reduction: list[Reduction] = field(default_factory=list) + schedule: Schedule|None = None @dataclass -class NumThreads(Clause): - id: ClassVar[str] = "num_threads" - expr: PyExpr +class Distribute(Construct): + id: ClassVar[str] = "distribute" + allocate: list[AllocateClause] = field(default_factory=list) + collapse: Collapse|None = None + dist_schedule: DistSchedule|None = None + first_private: list[FirstPrivate] = field(default_factory=list) + induction: list[Induction] = field(default_factory=list) + last_private: list[LastPrivate] = field(default_factory=list) + order: Order|None = None + private: list[Private] = field(default_factory=list) @dataclass -class OrderedClause(Clause): - id: ClassVar[str] = "ordered" - n: PyInt | None = None +class Loop(Construct): + id: ClassVar[str] = "loop" + bind: Bind|None = None +#### TASKING CONSTRUCTS #### + @dataclass -class Private(DataScope): - id: ClassVar[str] = "private" +class Task(Construct): + id: ClassVar[str] = "task" + # TODO: Detach and Mergeable are exclusive + affinity: list[Affinity] = field(default_factory=list) + allocate: list[AllocateClause] = field(default_factory=list) + default: Default|None = None + depend: list[Depend] = field(default_factory=list) + detach: Detach|None = None + final: Final|None = None + first_private: list[FirstPrivate] = field(default_factory=list) + if_: If|None = None + in_reduction: list[InReduction] = field(default_factory=list) + mergeable: Mergeable|None = None + priority: Priority|None = None + private: list[Private] = field(default_factory=list) + replayable: list[Replayable] = field(default_factory=list) + shared: list[Shared] = field(default_factory=list) + thread_set: ThreadSet|None = None + transparent: Transparent|None = None + untied: Untied|None = None @dataclass -class ProcBind(Clause): - id: ClassVar[str] = "proc_bind" - ntype: Name +class Taskloop(Construct): + id: ClassVar[str] = "taskloop" + # TODO: NoGroup and Reduction are exclusive + # TODO: GrainSize and NumTasks are exclusive + allocate: list[AllocateClause] = field(default_factory=list) + collapse: Collapse|None = None + default: Default|None = None + final: Final|None = None + first_private: list[FirstPrivate] = field(default_factory=list) + grain_size: GrainSize|None = None + if_: If|None = None + in_reduction: list[InReduction] = field(default_factory=list) + induction: list[Induction] = field(default_factory=list) + last_private: list[LastPrivate] = field(default_factory=list) + mergeable: Mergeable|None = None + no_group: NoGroup|None = None + num_tasks: list[NumTasks] = field(default_factory=list) + priority: Priority|None = None + private: list[Private] = field(default_factory=list) + reduction: list[Reduction] = field(default_factory=list) + replayable: list[Replayable] = field(default_factory=list) + shared: list[Shared] = field(default_factory=list) + thread_set: ThreadSet|None = None + transparent: Transparent|None = None + untied: Untied|None = None - class Type(Enum): - MASTER = 0 - CLOSE = 1 - SPREAD = 2 - def __post_init__(self) -> None: - object.__setattr__( - self, - "kind", - { - "master": self.Type.MASTER, - "close": self.Type.CLOSE, - "spread": self.Type.SPREAD, - }[self.ntype.string.lower()], - ) +@dataclass +class TaskIteration(Construct): + id: ClassVar[str] = "task_iteration" + affinity: list[Affinity] = field(default_factory=list) + depend: list[Depend] = field(default_factory=list) + if_: If|None = None + - type: Type = field(init=False) +@dataclass +class Taskyield(Construct): + id: ClassVar[str] = "taskyield" @dataclass -class Reduction(DataScope): - id: ClassVar[str] = "reduction" - op: ReductionOp +class Taskgraph(Construct): + id: ClassVar[str] = "taskgraph" + graph_id: GraphId|None = None + graph_reset: GraphReset|None = None + if_: If|None = None + no_group: NoGroup|None = None + + +#### DEVICE DIRECTIVES & CONSTRUCTS #### + +@dataclass(kw_only=True) +class TargetData(Construct): + id: ClassVar[str] = "target_data" + # TODO: Map, UseDeviceAddr, UseDevicePtr are required + affinity: list[Affinity] = field(default_factory=list) + allocate: list[AllocateClause] = field(default_factory=list) + default: Default|None = None + depend: list[Depend] = field(default_factory=list) + detach: Detach|None = None + device: Device|None = None + first_private: list[FirstPrivate] = field(default_factory=list) + if_: If|None = None + in_reduction: list[InReduction] = field(default_factory=list) + map: list[Map] = field(default_factory=list) + mergeable: Mergeable|None = None + no_group: NoGroup|None = None + no_wait: NoWait|None = None + priority: Priority|None = None + private: list[Private] = field(default_factory=list) + shared: list[Shared] = field(default_factory=list) + transparent: Transparent|None = None + use_device_ptr: list[UseDevicePtr] = field(default_factory=list) + use_device_addr: list[UseDeviceAddr] = field(default_factory=list) @dataclass -class Schedule(Clause): - id: ClassVar[str] = "schedule" - type: ScheduleType - chunk: PyExpr | None = None +class TargetEnterData(Construct): + id: ClassVar[str] = "target_enter_data" + depend: list[Depend] = field(default_factory=list) + device: Device|None = None + if_: If|None = None + map: list[Map] = field(default_factory=list) + no_wait: NoWait|None = None + priority: Priority|None = None + replayable: list[Replayable] = field(default_factory=list) @dataclass -class Shared(DataScope): - id: ClassVar[str] = "shared" +class TargetExitData(Construct): + id: ClassVar[str] = "target_exit_data" + depend: list[Depend] = field(default_factory=list) + device: Device|None = None + if_: If|None = None + map: list[Map] = field(default_factory=list) + no_wait: NoWait|None = None + priority: Priority|None = None + replayable: list[Replayable] = field(default_factory=list) -####################################################################################################################### -###################################################### Modifiers ###################################################### -####################################################################################################################### +@dataclass +class Target(Construct): + id: ClassVar[str] = "target" + allocate: list[AllocateClause] = field(default_factory=list) + default: Default|None = None + default_map: DefaultMap|None = None + depend: list[Depend] = field(default_factory=list) + device: Device|None = None + device_type: DeviceType|None = None + first_private: list[FirstPrivate] = field(default_factory=list) + has_device_addr: list[HasDeviceAddr] = field(default_factory=list) + if_: If|None = None + in_reduction: list[InReduction] = field(default_factory=list) + is_device_ptr: list[IsDevicePtr] = field(default_factory=list) + map: list[Map] = field(default_factory=list) + no_wait: NoWait|None = None + private: list[Private] = field(default_factory=list) + priority: Priority|None = None + replayable: list[Replayable] = field(default_factory=list) + thread_limit: ThreadLimit|None = None + uses_allocators: list[UsesAllocators] = field(default_factory=list) @dataclass -class Modifier(OmpNode): - id: ClassVar[str] = "modifier" # must be redefined +class TargetUpdate(Construct): + id: ClassVar[str] = "target_update" + # TODO: From and To are required + depend: list[Depend] = field(default_factory=list) + device: Device|None = None + from_: list[From] = field(default_factory=list) + if_: If|None = None + no_wait: NoWait|None = None + priority: Priority|None = None + replayable: list[Replayable] = field(default_factory=list) + to: list[To] = field(default_factory=list) +#### INTEROPERABITLITY CONSTRUCTS #### + @dataclass -class ReductionOp(Modifier): - id: ClassVar[str] = "op" - value: str +class InteropConstruct(Construct): + id: ClassVar[str] = "interop_construct" + # TODO: Destroy, Init and Use are required + depend: list[Depend] = field(default_factory=list) + destroy: list[Destroy] = field(default_factory=list) + device: Device|None = None + init: list[Init] = field(default_factory=list) + no_wait: NoWait|None = None + use: list[Use] = field(default_factory=list) +#### SYNCHRONIZATION CONSTRUCTS #### + @dataclass -class ScheduleType(Modifier): - id: ClassVar[str] = "type" - nkind: Name +class Critical(Construct): + id: ClassVar[str] = "critical" + critical_name: PyName|None = None + hint: Hint|None = None - class Kind(Enum): - STATIC = 0 + +@dataclass +class Barrier(Construct): + id: ClassVar[str] = "barrier" + + +@dataclass +class Taskgroup(Construct): + id: ClassVar[str] = "taskgroup" + allocate: list[AllocateClause] = field(default_factory=list) + task_reduction: list[TaskReduction] = field(default_factory=list) + + +@dataclass +class Taskwait(Construct): + id: ClassVar[str] = "taskwait" + depend: list[Depend] = field(default_factory=list) + no_wait: NoWait|None = None + replayable: list[Replayable] = field(default_factory=list) + + +@dataclass +class Atomic(Construct): + id: ClassVar[str] = "atomic" + + # TODO: memory-order and atomic groups are exclusive + mem_scope: MemScope|None = None + hint: Hint|None = None + # atomic clause group: + read: Read|None = None + update: Update|None = None + write: Write|None = None + # extended-atomic clause group: + capture: Capture|None = None + compare: Compare|None = None + fail: Fail|None = None + weak: Weak|None = None + # memory-order clause group: + acq_rel: AcqRel|None = None + acquire: Acquire|None = None + relaxed: Relaxed|None = None + release: Release|None = None + seq_cst: SeqCst|None = None + + +@dataclass +class Flush(Construct): + id: ClassVar[str] = "flush" + targets: list[PyName]|None = None + + mem_scope: MemScope|None = None + # memory-order clause group: + acq_rel: AcqRel|None = None + acquire: Acquire|None = None + relaxed: Relaxed|None = None + release: Release|None = None + seq_cst: SeqCst|None = None + + @property + def str_targets(self) -> list[str]: + return [v.string for v in self.targets or []] + + +@dataclass +class Depobj(Construct): + id: ClassVar[str] = "depobj" + object: PyName + # TODO: destroy, init and update are required + destroy: Destroy|None = None + init: Init|None = None + depobj_update: DepobjUpdate|None = None + + +@dataclass +class Ordered(Construct): + id: ClassVar[str] = "ordered" + # TODO: DoAcross and SimdClause/Threads are exclusive + do_across: DoAcross|None = None + simd: SimdClause|None = None + threads: Threads|None = None + + +#### CANCELLATION CONSTRUCTS #### + +class CancelDirectiveName(Enum): + FOR = 0 + PARALLEL = 1 + SECTIONS = 2 + TASKGROUP = 3 + + @staticmethod + def from_name(name: Name) -> CancelDirectiveName: + return { + "for": CancelDirectiveName.FOR, + "parallel": CancelDirectiveName.PARALLEL, + "sections": CancelDirectiveName.SECTIONS, + "taskgroup": CancelDirectiveName.TASKGROUP, + }[name.string.lower()] + + +@dataclass(kw_only=True) +class Cancel(Construct): + id: ClassVar[str] = "cancel" + directive_name: DirectiveName|None = None + construct_type_name: Name + construct_type: CancelDirectiveName = field(init=False) + + if_: If|None = None + + def __post_init__(self) -> None: + object.__setattr__(self, "construct_type", CancelDirectiveName.from_name(self.construct_type_name)) + + +@dataclass +class CancellationPoint(Construct): + id: ClassVar[str] = "cancellationpoint" + construct_type_name: Name + construct_type: CancelDirectiveName = field(init=False) + + def __post_init__(self) -> None: + object.__setattr__(self, "construct_type", CancelDirectiveName.from_name(self.construct_type_name)) + + +####################################################################################################################### +####################################################### Clauses ####################################################### +####################################################################################################################### + + +#### declare reduction #### +@dataclass +class Combiner(Clause): + id: ClassVar[str] = "combiner" + combiner_stmt: PyStmt + +@dataclass +class Initializer(Clause): + id: ClassVar[str] = "initializer" + initializer_stmt: PyStmt + + +#### declare induction #### +@dataclass +class Inductor(Clause): + id: ClassVar[str] = "inductor" + inductor_stmt: PyStmt + +@dataclass +class Collector(Clause): + id: ClassVar[str] = "collector" + collector_expr: PyExpr + + +#### scan #### +@dataclass +class Exclusive(DataScope): + id: ClassVar[str] = "exclusive" + +@dataclass +class Inclusive(DataScope): + id: ClassVar[str] = "inclusive" + +@dataclass +class InitComplete(Clause): + id: ClassVar[str] = "init_complete" + create_init_phase: PyExpr|None = None + +#### groupprivate #### +@dataclass +class DeviceType(Clause): + id: ClassVar[str] = "device_type" + device_type_description_name: Name + device_type_description: Kind = field(init=False) + + class Kind(Enum): + ANY = 0 + HOST = 1 + NOHOST = 2 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "device_type_description", + { + "any": self.Kind.ANY, + "host": self.Kind.HOST, + "nohost": self.Kind.NOHOST, + }[self.device_type_description_name.string.lower()], + ) + + +#### allocate #### +@dataclass +class Align(Clause): + id: ClassVar[str] = "align" + alignment: PyExpr + +@dataclass +class Allocator(Clause): + id: ClassVar[str] = "allocator" + allocator: PyExpr + + +#### metadirective #### +@dataclass +class When(Clause): + id: ClassVar[str] = "when" + directive: Directive + # modifiers: + context_selector: ContextSelector + +@dataclass +class Otherwise(Clause): + id: ClassVar[str] = "otherwise" + directive: Directive|None = None + + +#### declare_variant #### +@dataclass +class AdjustArgs(DataScope): + id: ClassVar[str] = "adjust_args" + # modifiers: + adjust_op_name: Name + adjust_op: AdjustOp = field(init=False) + + class AdjustOp(Enum): + NOTHING = 0 + NEED_DEVICE_PTR = 1 + NEED_DEVICE_ADDR = 2 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "adjust_op", + { + "nothing": self.AdjustOp.NOTHING, + "need_device_ptr": self.AdjustOp.NEED_DEVICE_PTR, + "need_device_addr": self.AdjustOp.NEED_DEVICE_ADDR, + }[self.adjust_op_name.string.lower()], + ) + +@dataclass +class AppendArgs(Clause): + id: ClassVar[str] = "append_args" + append_op: list[InteropModifier] = field(default_factory=list) + +@dataclass +class Match(Clause): + id: ClassVar[str] = "match" + context_selector: ContextSelector + + +#### dispatch #### +@dataclass +class InteropClause(DataScope): + id: ClassVar[str] = "interop" + +@dataclass +class IsDevicePtr(DataScope): + id: ClassVar[str] = "is_device_ptr" + +@dataclass +class HasDeviceAddr(DataScope): + id: ClassVar[str] = "has_device_addr" + +@dataclass +class NoContext(Clause): + id: ClassVar[str] = "no_context" + dont_update_context: PyExpr + +@dataclass +class NoVariants(Clause): + id: ClassVar[str] = "no_variants" + dont_use_variant: PyExpr + + +#### declare_simd #### +@dataclass +class Aligned(DataScope): + id: ClassVar[str] = "aligned" + # modifiers: + alignment_modifier: PyInt|None = None + +@dataclass +class Linear(DataScope): + id: ClassVar[str] = "linear" + # modifiers: + step_simple_modifier: PyExpr|None = None + step_modifier: Step|None = None + linear_modifier_name: Name|None = None + linear_modifier: LinearModifier|None = field(init=False) + + class LinearModifier(Enum): + REF = 0 + UVAL = 1 + VAL = 2 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "linear_modifier", + { + "ref": self.LinearModifier.REF, + "uval": self.LinearModifier.UVAL, + "val": self.LinearModifier.VAL, + }[self.linear_modifier_name.string.lower()] + if self.linear_modifier_name is not None + else None + ) + +@dataclass +class Simdlen(Clause): + id: ClassVar[str] = "simdlen" + length: PyExpr + +@dataclass +class Uniform(DataScope): + id: ClassVar[str] = "uniform" + +@dataclass +class InBranch(Clause): + id: ClassVar[str] = "in_branch" + in_branch: PyExpr|None = None + +@dataclass +class NotInBranch(Clause): + id: ClassVar[str] = "not_in_branch" + not_in_branch: PyExpr|None = None + + +#### declare_target #### +@dataclass +class Enter(DataScope): + id: ClassVar[str] = "enter" + # modifiers: + automap_name: Name|None = None + +@dataclass +class Indirect(Clause): + id: ClassVar[str] = "indirect" + invoked_by_fptr: PyExpr + +@dataclass +class Link(DataScope): + id: ClassVar[str] = "link" + +@dataclass +class Local(DataScope): + id: ClassVar[str] = "local" + + +#### requires #### +@dataclass +class AtomicDefaultMemOrder(Clause): + id: ClassVar[str] = "atomic_default_mem_order" + memory_order_name: Name + memory_order: MemoryOrder = field(init=False) + + class MemoryOrder(Enum): + ACQ_REL = 0 + ACQUIRE = 1 + RELAXED = 2 + SEQ_CST = 3 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "kind", + { + "acq_rel": self.MemoryOrder.ACQ_REL, + "acquire": self.MemoryOrder.ACQUIRE, + "relaxed": self.MemoryOrder.RELAXED, + "seq_cst": self.MemoryOrder.SEQ_CST, + }[self.memory_order_name.string.lower()] + ) + +@dataclass +class DynamicAllocators(Clause): + id: ClassVar[str] = "dynamic_allocators" + required: PyExpr|None = None + +@dataclass +class ReverseOffload(Clause): + id: ClassVar[str] = "reverse_offload" + required: PyExpr|None = None + +@dataclass +class UnifiedAddress(Clause): + id: ClassVar[str] = "unified_address" + required: PyExpr|None = None + +@dataclass +class UnifiedSharedMemory(Clause): + id: ClassVar[str] = "unified_shared_memory" + required: PyExpr|None = None + +@dataclass +class SelfMaps(Clause): + id: ClassVar[str] = "self_maps" + required: PyExpr|None = None + +@dataclass +class DeviceSafesync(Clause): + id: ClassVar[str] = "device_safesync" + required: PyExpr|None = None + + +#### assume #### +@dataclass +class Absent(Clause): + id: ClassVar[str] = "absent" + directive_names: list[DirectiveName] = field(default_factory=list) + +@dataclass +class Contains(Clause): + id: ClassVar[str] = "contains" + directive_names: list[DirectiveName] = field(default_factory=list) + +@dataclass +class Holds(Clause): + id: ClassVar[str] = "holds" + hold_expr: PyExpr + +@dataclass +class NoOpenmp(Clause): + id: ClassVar[str] = "no_openmp" + can_assume: PyExpr|None = None + +@dataclass +class NoOpenmpConstructs(Clause): + id: ClassVar[str] = "no_openmp_constructs" + can_assume: PyExpr|None = None + +@dataclass +class NoOpenmpRoutines(Clause): + id: ClassVar[str] = "no_openmp_routines" + can_assume: PyExpr|None = None + +@dataclass +class NoParallelism(Clause): + id: ClassVar[str] = "no_parallelism" + can_assume: PyExpr|None = None + + +#### error #### +@dataclass(kw_only=True) +class At(Clause): + id: ClassVar[str] = "at" + action_time_name: Name + action_time: ActionTime = field(init=False) + + class ActionTime(Enum): + COMPILATION = 0 + EXECUTION = 1 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "action_time", + { + "compilation": self.ActionTime.COMPILATION, + "execution": self.ActionTime.EXECUTION, + }[self.action_time_name.string.lower()] + ) + +@dataclass +class Message(Clause): + id: ClassVar[str] = "message" + msg_string: PyExpr + +@dataclass +class Severity(Clause): + id: ClassVar[str] = "severity" + severity_level_name: Name + severity_level: SeverityLevel = field(init=False) + + class SeverityLevel(Enum): + FATAL = 0 + WARNING = 1 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "severity_level", + { + "fatal": self.SeverityLevel.FATAL, + "warning": self.SeverityLevel.WARNING, + }[self.severity_level_name.string.lower()] + ) + + +#### fuse #### +@dataclass +class LoopRange(Clause): + id: ClassVar[str] = "looprange" + first: PyExpr + count: PyExpr + +#### interchange #### +@dataclass +class Permutation(Clause): + id: ClassVar[str] = "permutation" + permutation_list: list[PyExpr] = field(default_factory=list) + +#### split #### +@dataclass +class Counts(Clause): + id: ClassVar[str] = "counts" + count_list: list[PyExpr] = field(default_factory=list) + +#### stripe #### +@dataclass +class Sizes(Clause): + id: ClassVar[str] = "sizes" + size_list: list[PyExpr] = field(default_factory=list) + +#### unroll #### +@dataclass +class Full(Clause): + id: ClassVar[str] = "full" + fully_unroll: PyExpr|None = None + +class Partial(Clause): + id: ClassVar[str] = "partial" + unroll_factor: PyExpr|None = None + + +#### parallel #### +@dataclass +class CopyIn(DataScope): + id: ClassVar[str] = "copyin" + +@dataclass +class NumThreads(Clause): + id: ClassVar[str] = "num_threads" + nthreads: PyExpr + # modifiers: + strict_name: Name|None = None + +@dataclass +class ProcBind(Clause): + id: ClassVar[str] = "proc_bind" + affinity_policy_name: Name + affinity_policy: AffinityPolicy = field(init=False) + + class AffinityPolicy(Enum): + CLOSE = 0 + PRIMARY = 1 + SPREAD = 2 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "kind", + { + "close": self.AffinityPolicy.CLOSE, + "primary": self.AffinityPolicy.PRIMARY, + "spread": self.AffinityPolicy.SPREAD, + }[self.affinity_policy_name.string.lower()], + ) + +@dataclass +class SafeSync(Clause): + id: ClassVar[str] = "safesync" + width: PyExpr|None = None + +#### teams #### +@dataclass +class NumTeams(Clause): + id: ClassVar[str] = "num_teams" + upper_bound: PyExpr + lower_bound: PyExpr|None = None + +@dataclass +class ThreadLimit(Clause): + id: ClassVar[str] = "thread_limit" + threadlim: PyExpr + + +#### simd #### +@dataclass +class NonTemporal(DataScope): + id: ClassVar[str] = "non_temporal" + +@dataclass +class Order(Clause): + id: ClassVar[str] = "non_temporal" + ordering: Name + # modifiers: + order_modifier_name: Name|None = None + order_modifier: OrderModifier|None = field(init=False) + + class OrderModifier(Enum): + REPRODUCIBLE = 0 + UNCONSTRAINED = 1 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "order_modifier", + { + "reproducible": self.OrderModifier.REPRODUCIBLE, + "unconstrained": self.OrderModifier.UNCONSTRAINED, + }[self.order_modifier_name.string.lower()] + if self.order_modifier_name is not None + else None + ) + +@dataclass +class SafeLen(Clause): + id: ClassVar[str] = "safelen" + length: PyExpr + + +#### masked #### +@dataclass +class Filter(Clause): + id: ClassVar[str] = "filter" + thread_num: PyExpr + + +#### single #### +@dataclass +class CopyPrivate(DataScope): + id: ClassVar[str] = "copyprivate" + + +#### for #### +@dataclass +class OrderedClause(Clause): + id: ClassVar[str] = "ordered" + n: PyInt|None = None + +@dataclass +class Schedule(Clause): + id: ClassVar[str] = "schedule" + type: ScheduleType + chunk: PyExpr|None = None + # modifiers: + ordering_modifier_name: Name|None = None + ordering_modifier: OrderingModifier|None = field(init=False) + chunk_modifier_name: Name|None = None + + class OrderingModifier(Enum): + MONOTONIC = 0 + NON_MONOTONIC = 0 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "ordering_modifier", + { + "monotonic": self.OrderingModifier.MONOTONIC, + "nonmonotonic": self.OrderingModifier.NON_MONOTONIC, + }[self.ordering_modifier_name.string.lower()] + if self.ordering_modifier_name is not None + else None + ) + + +#### distribute #### +@dataclass +class DistSchedule(Clause): + id: ClassVar[str] = "dist_schedule" + static: Name # = static + chunk_size: PyExpr|None = None + + +#### loop #### +@dataclass +class Bind(Clause): + id: ClassVar[str] = "bind" + binding_name: Name + binding: BindingKind = field(init=False) + + class BindingKind(Enum): + PARALLEL = 0 + TEAMS = 1 + THREAD = 2 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "binding", + { + "parallel": self.BindingKind.PARALLEL, + "teams": self.BindingKind.TEAMS, + "thread": self.BindingKind.THREAD, + }[self.binding_name.string.lower()] + ) + + +#### taskloop #### +@dataclass +class GrainSize(Clause): + id: ClassVar[str] = "grain_size" + grain_size: PyExpr + # modifiers: + strict_name: Name|None = None + +@dataclass +class NumTasks(Clause): + id: ClassVar[str] = "num_tasks" + num_tasks: PyExpr + # modifiers: + strict: Name|None = None + + +#### taskgraph #### +@dataclass +class GraphId(Clause): + id: ClassVar[str] = "graph_id" + graph_id_value: PyExpr + +@dataclass +class GraphReset(Clause): + id: ClassVar[str] = "graph_reset" + expr: PyExpr + +#### target_data #### +@dataclass +class UseDevicePtr(DataScope): + id: ClassVar[str] = "use_device_ptr" + +@dataclass +class UseDeviceAddr(DataScope): + id: ClassVar[str] = "use_device_addr" + + +#### target #### +class VariableCategory(Enum): + ALL = 0 + AGGREGATE = 1 + ALLOCATABLE = 2 + POINTER = 3 + SCALAR = 4 + + @staticmethod + def from_name(name: Name|None) -> VariableCategory|None: + return ( + { + "all": VariableCategory.ALL, + "aggregate": VariableCategory.AGGREGATE, + "allocatable": VariableCategory.ALLOCATABLE, + "pointer": VariableCategory.POINTER, + "scalar": VariableCategory.SCALAR, + }[name.string.lower()] + if name is not None + else None + ) + +@dataclass +class DefaultMap(Clause): + id: ClassVar[str] = "use_device_addr" + implicit_behavior_name: Name + implicit_behavior: ImplicitBehavior = field(init=False) + # modifiers: + variable_category_name: Name|None = None + variable_category: VariableCategory|None = None + + class ImplicitBehavior(Enum): + DEFAULT = 0 + FIRST_PRIVATE = 1 + FROM = 2 + NONE = 3 + PRESENT = 4 + PRIVATE = 5 + SELF = 6 + STORAGE = 7 + TO = 8 + TOFROM = 9 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "implicit_behavior", + { + "default ": self.ImplicitBehavior.DEFAULT, + "first_private ": self.ImplicitBehavior.FIRST_PRIVATE, + "from ": self.ImplicitBehavior.FROM, + "none ": self.ImplicitBehavior.NONE, + "present ": self.ImplicitBehavior.PRESENT, + "private ": self.ImplicitBehavior.PRIVATE, + "self ": self.ImplicitBehavior.SELF, + "storage ": self.ImplicitBehavior.STORAGE, + "to ": self.ImplicitBehavior.TO, + "tofrom ": self.ImplicitBehavior.TOFROM, + }[self.implicit_behavior_name.string.lower()], + ) + object.__setattr__(self, "variable_category", VariableCategory.from_name(self.variable_category_name)) + +@dataclass +class UsesAllocators(Clause): + id: ClassVar[str] = "use_device_addr" + allocator: PyExpr + # modifiers: + memspace_modifier: MemSpace|None = None + traits_modifier: Traits|None = None + + +#### target_update #### +@dataclass +class From(DataScope): + id: ClassVar[str] = "from_" + # modifiers: + present_name: Name|None = None + mapper_modifier: Mapper|None = None + iterator_modifier: Iterator|None = None + + +@dataclass +class To(DataScope): + id: ClassVar[str] = "to" + # modifiers: + present_name: Name|None = None + mapper_modifier: Mapper|None = None + iterator_modifier: Iterator|None = None + + +#### interop #### +@dataclass +class Destroy(Clause): + id: ClassVar[str] = "destroy" + destroy_var: PyName + +@dataclass +class Init(Clause): + id: ClassVar[str] = "init" + init_var: PyName + # modifiers: + prefer_modifier: Prefer|None = None + depinfo_modifier: DepInfo|None = None + interop_type_modifier_name: list[Name] = field(default_factory=list) + interop_type_modifier: list[InteropType] = field(init=False) + + class InteropType(Enum): + TARGET = 0 + TARGETSYNC = 1 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "interop_type_modifier", + [{ + "target": self.InteropType.TARGET, + "targetsync": self.InteropType.TARGETSYNC, + }[e.string.lower()] for e in self.interop_type_modifier_name] + ) + +@dataclass +class Use(Clause): + id: ClassVar[str] = "use" + interop_var: PyName + + +#### critical #### +@dataclass +class Hint(Clause): + id: ClassVar[str] = "hint" + expr: PyExpr + + +#### taskgroup #### +@dataclass +class TaskReduction(DataScope): + id: ClassVar[str] = "task_reduction" + op: ReductionOp + + +#### atomic #### +@dataclass +class MemScope(Clause): + id: ClassVar[str] = "mem_scope" + scope_name: Name + scope: ScopeType = field(init=False) + + class ScopeType(Enum): + ALL = 0 + CGROUP = 1 + DEVICE = 2 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "scope", + { + "all": self.ScopeType.ALL, + "cgroup": self.ScopeType.CGROUP, + "device": self.ScopeType.DEVICE, + }[self.scope_name.string.lower()] + ) + +@dataclass +class Read(Clause): + id: ClassVar[str] = "read" + use_semantics: PyExpr|None = None +@dataclass +class Update(Clause): + id: ClassVar[str] = "update" + use_semantics: PyExpr|None = None +@dataclass +class Write(Clause): + id: ClassVar[str] = "write" + use_semantics: PyExpr|None = None + +@dataclass +class Capture(Clause): + id: ClassVar[str] = "capture" + use_semantics: PyExpr|None = None +@dataclass +class Compare(Clause): + id: ClassVar[str] = "compare" + use_semantics: PyExpr|None = None +@dataclass +class Fail(Clause): + id: ClassVar[str] = "fail" + mem_order_name: Name + mem_order: MemOrder = field(init=False) + class MemOrder(Enum): + ACQUIRE = 0 + RELAXED = 1 + SEQ_CST = 2 + def __post_init__(self) -> None: + object.__setattr__( + self, + "mem_order", + { + "acquire": self.MemOrder.ACQUIRE, + "relaxed": self.MemOrder.RELAXED, + "seq_cst": self.MemOrder.SEQ_CST, + }[self.mem_order_name.string.lower()] + ) +@dataclass +class Weak(Clause): + id: ClassVar[str] = "weak" + use_semantics: PyExpr|None = None + +@dataclass +class AcqRel(Clause): + id: ClassVar[str] = "acq_rel" + use_semantics: PyExpr|None = None +@dataclass +class Acquire(Clause): + id: ClassVar[str] = "acquire" + use_semantics: PyExpr|None = None +@dataclass +class Relaxed(Clause): + id: ClassVar[str] = "relaxed" + use_semantics: PyExpr|None = None +@dataclass +class Release(Clause): + id: ClassVar[str] = "release" + use_semantics: PyExpr|None = None +@dataclass +class SeqCst(Clause): + id: ClassVar[str] = "seq_cst" + use_semantics: PyExpr|None = None + + +#### depobj #### +@dataclass +class DepobjUpdate(Clause): + id: ClassVar[str] = "depobj_update" + update_var: PyName + # modifiers: + task_dependence_name: Name|None = None + task_dependence: TaskDependenceKind|None = field(init=False) + + def __post_init__(self) -> None: + object.__setattr__( + self, + "task_dependence", + TaskDependenceKind.from_name(self.task_dependence_name) + ) + + +#### ordered #### +@dataclass +class DoAcross(Clause): + id: ClassVar[str] = "do_across" + iterator_specifier: IteratorSpecifier + # modifiers: + dependence_type_name: Name + dependence_type: DependenceType = field(init=False) + + class DependenceType(Enum): + SINK = 0 + SOURCE = 1 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "dependence_type", + { + "sink": self.DependenceType.SINK, + "source": self.DependenceType.SOURCE, + }[self.dependence_type_name.string.lower()] + ) + + +@dataclass +class SimdClause(Clause): + id: ClassVar[str] = "simd" + appy_to_simd: PyExpr|None = None + + +@dataclass +class Threads(Clause): + id: ClassVar[str] = "threads" + appy_to_threads: PyExpr|None = None + + +######################## +#### common clauses #### +######################## + +@dataclass +class Apply(Clause): + id: ClassVar[str] = "apply" + directives: list[Name] = field(default_factory=list) + # modifiers: + loop_modifier: LoopModifier|None = None + + +class TaskDependenceKind(Enum): + DEPOBJ = 0 + IN = 1 + INOUT = 2 + INOUTSET = 3 + MUTEXINOUTSET = 4 + OUT = 5 + + @staticmethod + def from_name(name: Name|None) -> TaskDependenceKind|None: + return ( + { + "depobj": TaskDependenceKind.DEPOBJ, + "in": TaskDependenceKind.IN, + "inout": TaskDependenceKind.INOUT, + "inoutset": TaskDependenceKind.INOUTSET, + "mutexinoutset": TaskDependenceKind.MUTEXINOUTSET, + "out": TaskDependenceKind.OUT, + }[name.string.lower()] + if name is not None + else None + ) + + +@dataclass +class Depend(Clause): + id: ClassVar[str] = "depend" + locator_list: list[PyExpr] = field(default_factory=list) + # modifiers: + task_dependence_name: Name|None = None + task_dependence: TaskDependenceKind|None = field(init=False) + iterator_modifier: Iterator|None = None + + def __post_init__(self) -> None: + object.__setattr__( + self, + "task_dependence", + TaskDependenceKind.from_name(self.task_dependence_name) + ) + + +@dataclass +class Device(Clause): + id: ClassVar[str] = "device" + device_description: PyExpr + + # modifiers: + device_modifier_name: Name|None = None + device_modifier: DeviceModifier|None = field(init=False) + + class DeviceModifier(Enum): + ANCESTOR = 0 + DEVICE_NUM = 1 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "device_modifier", + { + "ancestor": self.DeviceModifier.ANCESTOR, + "device_num": self.DeviceModifier.DEVICE_NUM, + }[self.device_modifier_name.string.lower()] + if self.device_modifier_name is not None + else None + ) + + +@dataclass +class Default(Clause): + id: ClassVar[str] = "default" + data_sharing_attr_name: Name + data_sharing_attr: DataSharingAttr = field(init=False) + # modifiers: + variable_category_name: Name|None = None + variable_category: VariableCategory|None = None + + class DataSharingAttr(Enum): + SHARED = 0 + FIRST_PRIVATE = 1 + PRIVATE = 2 + NONE = 3 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "data_sharing_attr", + { + "shared": self.DataSharingAttr.SHARED, + "firstprivate": self.DataSharingAttr.FIRST_PRIVATE, + "private": self.DataSharingAttr.PRIVATE, + "none": self.DataSharingAttr.NONE, + }[self.data_sharing_attr_name.string.lower()], + ) + object.__setattr__( + self, + "variable_category", + VariableCategory.from_name(self.variable_category_name) + ) + + +@dataclass +class Private(DataScope): + id: ClassVar[str] = "private" + + +@dataclass +class If(Clause): + id: ClassVar[str] = "if_" + expr: PyExpr + + +@dataclass +class FirstPrivate(DataScope): + id: ClassVar[str] = "first_private" + # modifiers: + saved_name: Name|None = None + + +@dataclass +class Reduction(DataScope): + id: ClassVar[str] = "reduction" + op: ReductionOp + # modifiers: + reduction_modifier_name: Name|None = None + reduction_modifier: ReductionModifier|None = field(init=False) + original_modifier: Original|None = None + + class ReductionModifier(Enum): + DEFAULT = 0 + INSCAN = 1 + TASK = 2 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "reduction_modifier", + { + "default": self.ReductionModifier.DEFAULT, + "inscan": self.ReductionModifier.INSCAN, + "task": self.ReductionModifier.TASK, + }[self.reduction_modifier_name.string.lower()] + if self.reduction_modifier_name is not None + else None + ) + + +@dataclass +class Induction(DataScope): + id: ClassVar[str] = "induction" + op: InductionOp + # modifiers: + step_modifier: Step + induction_modifier_name: Name|None = None + induction_modifier: InductionModifier|None = field(init=False) + + class InductionModifier(Enum): + RELAXED = 0 + STRICT = 1 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "induction_modifier", + { + "relaxed": self.InductionModifier.RELAXED, + "strict": self.InductionModifier.STRICT, + }[self.induction_modifier_name.string.lower()] + if self.induction_modifier_name is not None + else None + ) + + +@dataclass +class Shared(DataScope): + id: ClassVar[str] = "shared" + + +@dataclass +class Collapse(Clause): + id: ClassVar[str] = "collapse" + num: PyInt + + +@dataclass +class LastPrivate(DataScope): + id: ClassVar[str] = "last_private" + # modifiers: + conditional_name: Name|None = None + + +@dataclass +class AllocateClause(DataScope): + id: ClassVar[str] = "allocate" + # modifiers: + allocator_simple_modifier: PyExpr|None = None + allocator_modifier: AllocatorModifier|None = None + align_modifier: AlignModifier|None = None + + +@dataclass +class NoWait(Clause): + id: ClassVar[str] = "no_wait" + dont_synchronize: PyExpr|None = None + + +@dataclass +class Final(Clause): + id: ClassVar[str] = "final" + finalize: PyExpr + + +@dataclass +class Mergeable(Clause): + id: ClassVar[str] = "mergeable" + can_merge: PyExpr|None = None + + +@dataclass +class Untied(Clause): + id: ClassVar[str] = "untied" + can_change_threads: PyExpr|None = None + + +@dataclass +class Affinity(DataScope): + id: ClassVar[str] = "affinity" + # modifiers: + iterator_modifier: Iterator|None = None + + +@dataclass +class Detach(Clause): + id: ClassVar[str] = "detach" + event_handle: PyName + + +@dataclass +class InReduction(DataScope): + id: ClassVar[str] = "in_reduction" + op: ReductionOp + + +@dataclass +class Priority(Clause): + id: ClassVar[str] = "priority" + value: PyExpr + + +@dataclass +class Replayable(Clause): + id: ClassVar[str] = "affinity" + expr: PyExpr + + +@dataclass +class ThreadSet(Clause): + id: ClassVar[str] = "thread_set" + set_name: Name + set: ThreadSetType = field(init=False) + + class ThreadSetType(Enum): + OMP_POOL = 0 + OMP_TEAM = 1 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "set", + { + "omp_pool": self.ThreadSetType.OMP_POOL, + "omp_team": self.ThreadSetType.OMP_TEAM, + }[self.set_name.string.lower()] + ) + + +@dataclass +class Transparent(Clause): + id: ClassVar[str] = "transparent" + impex_type: PyExpr|None = None + + +@dataclass +class NoGroup(Clause): + id: ClassVar[str] = "no_group" + dont_synchronize: PyExpr|None = None + + +@dataclass +class Map(DataScope): + id: ClassVar[str] = "map" + # modifiers: + always_modifier_name: Name|None = None + close_modifier_name: Name|None = None + present_modifier_name: Name|None = None + self_modifier_name: Name|None = None + delete_modifier_name: Name|None = None + + ref_modifier_name: Name|None = None + ref_modifier: RefModifier|None = field(init=False) + + map_type_name: Name|None = None + map_type: MapType|None = field(init=False) + + mapper_modifier: Mapper|None = None + iterator_modifier: Iterator|None = None + + class RefModifier(Enum): + REF_PTEE = 0 + REF_PTR = 1 + REF_PTR_PTEE = 2 + + class MapType(Enum): + FROM = 0 + STORAGE = 1 + TO = 2 + TOFROM = 3 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "ref_modifier", + { + "ref_ptee": self.RefModifier.REF_PTEE, + "ref_ptr": self.RefModifier.REF_PTR, + "ref_ptr_ptee": self.RefModifier.REF_PTR_PTEE, + }[self.ref_modifier_name.string.lower()] + if self.ref_modifier_name is not None + else None + ) + object.__setattr__( + self, + "map_type", + { + "from": self.MapType.FROM, + "storage": self.MapType.STORAGE, + "to": self.MapType.TO, + "tofrom": self.MapType.TOFROM, + }[self.map_type_name.string.lower()] + if self.map_type_name is not None + else None + ) + + +####################################################################################################################### +###################################################### Modifiers ###################################################### +####################################################################################################################### + +@dataclass +class ScheduleType(Modifier): + id: ClassVar[str] = "type" + kind_name: Name + kind: Kind = field(init=False) + + class Kind(Enum): + STATIC = 0 DYNAMIC = 1 GUIDED = 2 AUTO = 3 @@ -413,10 +2115,208 @@ def __post_init__(self) -> None: "guided": self.Kind.GUIDED, "auto": self.Kind.AUTO, "runtime": self.Kind.RUNTIME, - }[self.nkind.string.lower()], + }[self.kind_name.string.lower()], + ) + + +@dataclass +class ReductionOp(Modifier): + id: ClassVar[str] = "op" + value: str + +@dataclass +class InductionOp(Modifier): + id: ClassVar[str] = "op" + value: str + + +@dataclass +class Original(Modifier): + id: ClassVar[str] = "original_modifier" + name: Name # = original + sharing_name: Name + sharing: Sharing = field(init=False) + + class Sharing(Enum): + DEFAULT = 0 + PRIVATE = 1 + SHARED = 2 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "sharing", + { + "default": self.Sharing.DEFAULT, + "private": self.Sharing.PRIVATE, + "shared": self.Sharing.SHARED, + }[self.sharing_name.string.lower()] + ) + + +@dataclass +class InteropModifier(Modifier): + id: ClassVar[str] = "iterop_modifier" + name: Name # = interop + kind_name: list[Name] = field(default_factory=list) + kind: list[Kind] = field(init=False) + + class Kind(Enum): + TARGET = 0 + TARGETSYNC = 1 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "kind", + [{ + "target": self.Kind.TARGET, + "targetsync": self.Kind.TARGETSYNC, + }[e.string.lower()] for e in self.kind_name] + ) + + +@dataclass +class Iterator(Modifier): + id: ClassVar[str] = "iterator_modifier" + name: Name # = iterator + specifiers: list[IteratorSpecifier] = field(default_factory=list) + +@dataclass +class IteratorSpecifier(Modifier): + id: ClassVar[str] = "iterator_specifier" + name: PyName + begin: PyExpr + end: PyExpr + step: PyExpr|None = None + + +@dataclass +class Step(Modifier): + id: ClassVar[str] = "step_modifier" + name: Name + expr: PyExpr + + +@dataclass +class AllocatorModifier(Modifier): + id: ClassVar[str] = "allocator_modifier" + name: Name # = allocator + allocator: PyExpr + + +@dataclass +class AlignModifier(Modifier): + id: ClassVar[str] = "align_modifier" + name: Name # = align + alignment: PyExpr + + +@dataclass +class Mapper(Modifier): + id: ClassVar[str] = "mapper_modifier" + name: Name # = mapper + identifier: PyName + +@dataclass +class MemSpace(Modifier): + id: ClassVar[str] = "memspace_modifier" + name: Name # = memspace + handle: PyExpr + +@dataclass +class Traits(Modifier): + id: ClassVar[str] = "traits_modifier" + name: Name # = traits + traits: PyExpr + + +@dataclass +class DepInfo(Modifier): + id: ClassVar[str] = "depinfo_modifier" + name: Name + kind: Kind = field(init=False) + locator_list: list[PyName] = field(default_factory=list) + + class Kind(Enum): + IN = 0 + INOUT = 1 + INOUTSET = 2 + MUTEXINOUTSET = 3 + OUT = 4 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "kind", + { + "in": self.Kind.IN, + "inout": self.Kind.INOUT, + "inoutset": self.Kind.INOUTSET, + "mutexinoutset": self.Kind.MUTEXINOUTSET, + "out": self.Kind.OUT, + }[self.name.string.lower()] ) + +@dataclass +class LoopModifier(Modifier): + id: ClassVar[str] = "loop_modifier" + name: Name kind: Kind = field(init=False) + indices: list[PyExpr] = field(default_factory=list) + + class Kind(Enum): + FUSED = 0 + GRID = 1 + IDENTITY = 2 + INTERCHANGED = 3 + INTRATILE = 4 + OFFSETS = 5 + REVERSED = 6 + SPLIT = 7 + UNROLLED = 8 + + def __post_init__(self) -> None: + object.__setattr__( + self, + "kind", + { + "fused": self.Kind.FUSED, + "grid": self.Kind.GRID, + "identity": self.Kind.IDENTITY, + "interchanged": self.Kind.INTERCHANGED, + "intratile": self.Kind.INTRATILE, + "offsets": self.Kind.OFFSETS, + "reversed": self.Kind.REVERSED, + "split": self.Kind.SPLIT, + "unrolled": self.Kind.UNROLLED, + }[self.name.string.lower()] + ) + + +@dataclass +class Prefer(Modifier): + id: ClassVar[str] = "prefer_modifier" + name: Name # = prefer_type + spec: list[list[FrSelector|AttrSelector] | PyName] = field(default_factory=list) + +@dataclass +class FrSelector(Modifier): + name: Name + identifier: PyName + +@dataclass +class AttrSelector(Modifier): + name: Name + expr_list: list[PyExpr] + + +# TODO: this uses context_selector as a stmt_list, which is not exactly what the standard required +@dataclass +class ContextSelector(Modifier): + id: ClassVar[str] = "context_selector" + stmt_list: list[PyStmt] = field(default_factory=list) ####################################################################################################################### @@ -433,6 +2333,7 @@ class PyExpr(Modifier): """ value: expr + source: str @dataclass @@ -473,3 +2374,4 @@ class PyStmt(Modifier): """ value: stmt + source: str diff --git a/test/conftest.py b/test/conftest.py index 5a1fe8c..8024650 100644 --- a/test/conftest.py +++ b/test/conftest.py @@ -13,8 +13,9 @@ def pytest_addoption(parser: pytest.Parser) -> None: parser.addoption("--pure", action="store_true", help="force omp4py pure runtime") -def pytest_configure(config: pytest.Config)-> None: +def pytest_configure(config: pytest.Config) -> None: os.environ["OMP4PY_PURE"] = str(config.getoption("pure")) + config.addinivalue_line("markers", "no_isolate") def worker(q: multiprocessing.Queue, f: Callable[..., Any], timeout: float | None, *args, **kwargs)-> None: @@ -58,6 +59,8 @@ def pytest_collection_modifyitems(session: pytest.Session, config: pytest.Config if len(items) > 0: timeout: str | None = config.getoption("timeout") for item in items: + if item.get_closest_marker("no_isolate"): + continue item.obj = isolate(timeout if timeout is None else int(timeout), item.obj) diff --git a/test/parser/__init__.py b/test/parser/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/test/parser/test_clauses.py b/test/parser/test_clauses.py new file mode 100644 index 0000000..17df8d6 --- /dev/null +++ b/test/parser/test_clauses.py @@ -0,0 +1,484 @@ +from __future__ import annotations +from operator import sub +from inspect import getargs + +import traceback +from typing import Any + +import pytest + +from omp4py.core.parser import tree +from omp4py.core.parser.parser import _parse +from omp4py.core.parser.source_view import SourceView + + +def parse(code: str, prefix:str=' with omp("', suffix:str='"):\n') -> tree.Directive: + complete_code = prefix + code + suffix + sv = SourceView( + tree.Span(1, len(prefix), 1, len(prefix)+len(code)), + "", + complete_code.splitlines(), + complete_code, + ) + return _parse(code, sv) + + +def find_clause[T](directive: tree.Directive, clause_type: type[T]) -> T | None: + # It's fine to only get the first one because we will only test with one directive + for attr in vars(list(directive.constructs.values())[0]).values(): + if isinstance(attr, clause_type): + return attr + if isinstance(attr, list) and attr and isinstance(attr[0], clause_type): + return attr[0] + return None + + +#### SYNTAX ERRORS ############################################################# + + +@pytest.mark.no_isolate +@pytest.mark.parametrize("source", [ + "", + "test", + "(", + "for (", + "for )", + "for ,", + "for test", + "for , private(test)", + + "for private(test),", + "for private(test", + "for private(test abc)", + "for private(test,)", + "for private(test) abc", +]) +def test_clause_invalid_syntax(source: str) -> None: + with pytest.raises(SyntaxError) as e: + parse(source) + traceback.print_exception(e.value) + +@pytest.mark.no_isolate +@pytest.mark.parametrize("source", [ + "for private(test!)", + "for private(a+b)", + "for private(10)", + "for private(39+(10+42)*1)", +]) +def test_clause_invalid_identifier(source: str) -> None: + with pytest.raises(SyntaxError) as e: + parse(source) + +@pytest.mark.no_isolate +@pytest.mark.parametrize("source", [ + "simd aligned(x: )", + "simd aligned(x: -1)", + "simd aligned(x: 1.5)", + "simd aligned(x: 1+1)", + "simd aligned(x: n)", + + "simd aligned(x: 4__2)", + "simd aligned(x: 0b123)", + "simd aligned(x: 0b0__0)", + "simd aligned(x: 0o8)", + "simd aligned(x: 0o911)", + "simd aligned(x: 0o__1)", + "simd aligned(x: 0xF__F)", + "simd aligned(x: 0_x1F)", +]) +def test_clause_invalid_integer(source: str) -> None: + with pytest.raises(SyntaxError) as e: + parse(source) + +@pytest.mark.no_isolate +@pytest.mark.parametrize("source", [ + "parallel num_threads()", + "parallel num_threads( )", + "parallel num_threads(((((", + "parallel num_threads(((()", + "parallel num_threads(1+)", +]) +def test_clause_invalid_expr(source: str) -> None: + with pytest.raises(SyntaxError) as e: + parse(source) + traceback.print_exception(e.value) + +@pytest.mark.no_isolate +@pytest.mark.parametrize("source", [ + "declare reduce (+:test) combiner(test =)", + "declare reduce (+:test) combiner(if variable:\n\tprint('hello')\nelse:\n\tprint('bye'))", +]) +def test_clause_invalid_stmt(source: str) -> None: + with pytest.raises(SyntaxError) as e: + parse(source) + traceback.print_exception(e.value) + +## Missing arguments +## Directive name to create orphan clauses +## schedule +#"for schedule(test)", +#"for schedule()", +#"for schedule(static,)", +#"for schedule(static 10)", +#"for schedule(static, )", +#"for schedule(static, 1+)", +## reduction +#"for reduction(+)", +#"for reduction(max)", +#"for reduction(**:test)", +#"for reduction(*:test,)", +#"for reduction(:test)", +#"for reduction(+test)", +#"for reduction(+:)", +#"for reduction(and:)", +#"for reduction(+:10)", +## default +#"parallel default()", +#"parallel default(private)", +#"parallel default(true)", +#"parallel default(Shared)", +#"parallel default(None)", + + +@pytest.mark.no_isolate +@pytest.mark.parametrize("source", [ + "metadirective when(for private(x))", # context_selector + "declare variant(var) adjust_args(x)", # adjust_op_name +]) +def test_missing_clause_modifiers(source: str) -> None: + with pytest.raises(SyntaxError) as e: + parse(source) + traceback.print_exception(e.value) + + +#### SIMPLE CLAUSES ############################################################ + + +# Testing: var_list +@pytest.mark.no_isolate +@pytest.mark.parametrize("source,clause_type,targets,directive_name", [ + ("scan exclusive(test)", tree.Exclusive, ["test"], None), + ("scan exclusive(test, ççç, äîóòæ)", tree.Exclusive, ["test", "ççç", "äîóòæ"], None), + ("scan exclusive(scan: exclusive, scan)", tree.Exclusive, ["exclusive", "scan"], "scan"), + + ("scan inclusive(äîóòæ)", tree.Inclusive, ["äîóòæ"], None), + ("scan inclusive(scan: inclusive, scan)", tree.Inclusive, ["inclusive", "scan"], "scan"), + + ("for private(äîóòæ)", tree.Private, ["äîóòæ"], None), + ("for private(for: private, for)", tree.Private, ["private", "for"], "for"), + + ("parallel shared(äîóòæ)", tree.Shared, ["äîóòæ"], None), + ("parallel shared(parallel : shared, parallel)", tree.Shared, ["shared", "parallel"], "parallel"), + + ("for firstprivate(äîóòæ)", tree.FirstPrivate, ["äîóòæ"], None), + ("for firstprivate(for: firstprivate, for)", tree.FirstPrivate, ["firstprivate", "for"], "for"), + + ("for lastprivate(äîóòæ)", tree.LastPrivate, ["äîóòæ"], None), + ("for lastprivate(for: lastprivate, for)", tree.LastPrivate, ["lastprivate", "for"], "for"), + + ("parallel copyin(äîóòæ)", tree.CopyIn, ["äîóòæ"], None), + ("parallel copyin(parallel: copyin, parallel)", tree.CopyIn, ["copyin", "parallel"], "parallel"), + + ("single copyprivate(äîóòæ)", tree.CopyPrivate, ["äîóòæ"], None), + ("single copyprivate(single: copyprivate, single)", tree.CopyPrivate, ["copyprivate", "single"], "single"), + + ("dispatch interop(äîóòæ)", tree.InteropClause, ["äîóòæ"], None), + ("dispatch interop(dispatch: interop, dispatch)", tree.InteropClause, ["interop", "dispatch"], "dispatch"), + + ("dispatch is_device_ptr(äîóòæ)", tree.IsDevicePtr, ["äîóòæ"], None), + ("dispatch is_device_ptr(dispatch: is_device_ptr, dispatch)", tree.IsDevicePtr, ["is_device_ptr", "dispatch"], "dispatch"), + + ("dispatch has_device_addr(äîóòæ)", tree.HasDeviceAddr, ["äîóòæ"], None), + ("dispatch has_device_addr(dispatch: has_device_addr, dispatch)", tree.HasDeviceAddr, ["has_device_addr", "dispatch"], "dispatch"), + + ("declare simd uniform(äîóòæ)", tree.Uniform, ["äîóòæ"], None), + ("declare simd uniform(declare simd: uniform, declare_simd)", tree.Uniform, ["uniform", "declare_simd"], "declare_simd"), +]) +def test_data_scopes(source: str, clause_type: type[tree.DataScope], targets: list[str], directive_name: str|None) -> None: + directive = parse(source) + clause = find_clause(directive, clause_type) + assert clause is not None + assert clause.str_targets == targets + if directive_name is None: + assert clause.directive_name is None + else: + assert clause.directive_name is not None and clause.directive_name.string == directive_name + + +# Testing: py_expr +@pytest.mark.no_isolate +@pytest.mark.parametrize("source,clause_type,property,expr,directive_name", [ + ("parallel if(x > 0)", tree.If, "expr", "x > 0", None), + ("parallel if(True)", tree.If, "expr", "True", None), + ("parallel if(x > 0 and y < 10)", tree.If, "expr", "x > 0 and y < 10", None), + ("parallel if(foo(x, y))", tree.If, "expr", "foo(x, y)", None), + ("parallel if(n)", tree.If, "expr", "n", None), + ("parallel if(foo(x, y))", tree.If, "expr", "foo(x, y)", None), + ("parallel if(foo(\n\tx,\n\ty))", tree.If, "expr", "foo(\n\tx,\n\ty)", None), + + ("task final(True)", tree.Final, "finalize", "True", None), + ("task final(x > 0)", tree.Final, "finalize", "x > 0", None), + + ( + "declare_induction (+ : int) inductor(omp_var = 1+1) collector(omp_step * omp_idx + 1)", + tree.Collector, + "collector_expr", + "omp_step * omp_idx + 1", + None + ), + ( + "declare_induction (+ : int) inductor(declare_induction: omp_var = 1+1) collector(declare_induction: omp_step * omp_idx + 1)", + tree.Collector, + "collector_expr", + "omp_step * omp_idx + 1", + "declare_induction" + ), + + ("scan init_complete(x > 0)", tree.InitComplete, "create_init_phase", "x > 0", None), + ("scan init_complete(scan: x > 0)", tree.InitComplete, "create_init_phase", "x > 0", "scan"), + + ("allocate(x) align(2**10)", tree.Align, "alignment", "2**10", None), + ("allocate(x) align(allocate: 2**10)", tree.Align, "alignment", "2**10", "allocate"), + + ("allocate(x) allocator(omp4py.Allocator())", tree.Allocator, "allocator", "omp4py.Allocator()", None), + ("allocate(x) allocator(allocate: omp4py.Allocator())", tree.Allocator, "allocator", "omp4py.Allocator()", "allocate"), + + ("dispatch nocontext(True)", tree.NoContext, "dont_update_context", "True", None), + ("dispatch nocontext(dispatch: x > 0)", tree.NoContext, "dont_update_context", "x > 0", "dispatch"), + + ("dispatch novariants(True)", tree.NoVariants, "dont_use_variant", "True", None), + ("dispatch novariants(dispatch: x > 0)", tree.NoVariants, "dont_use_variant", "x > 0", "dispatch"), + + ("declare simd simdlen(x + y)", tree.Simdlen, "length", "x + y", None), + ("declare simd simdlen(declare simd: x + y)", tree.Simdlen, "length", "x + y", "declare_simd"), + + ("declare simd inbranch(True)", tree.InBranch, "in_branch", "True", None), + ("declare simd inbranch(declare simd: x > 0)", tree.InBranch, "in_branch", "x > 0", "declare_simd"), + + ("declare simd notinbranch(True)", tree.NotInBranch, "not_in_branch", "True", None), + ("declare simd notinbranch(declare simd: x > 0)", tree.NotInBranch, "not_in_branch", "x > 0", "declare_simd"), + + ("declare target indirect", tree.Indirect, "invoked_by_fptr", None, None), + ("declare target indirect(declare target: x > 0)", tree.Indirect, "invoked_by_fptr", "x > 0", "declare_target"), +]) +def test_expr(source: str, clause_type: type[tree.Clause], property: str, expr: str|None, directive_name: str|None) -> None: + directive = parse(source) + clause = find_clause(directive, clause_type) + assert clause is not None + assert hasattr(clause, property) + if expr is None: + assert getattr(clause, property) is None + else: + assert getattr(clause, property).source == expr + if directive_name is None: + assert clause.directive_name is None + else: + assert clause.directive_name is not None and clause.directive_name.string == directive_name + + +# Testing: py_stmt +@pytest.mark.no_isolate +@pytest.mark.parametrize("source,clause_type,property,stmt,directive_name", [ + ( + "declare_reduction (+:int) combiner(omp_out = omp_in + omp_out)", + tree.Combiner, + "combiner_stmt", + "omp_out = omp_in + omp_out", + None + ), + ( + "declare_reduction (+:int) combiner(declare_reduction: omp_out = omp_in + omp_out)", + tree.Combiner, + "combiner_stmt", + "omp_out = omp_in + omp_out", + "declare_reduction" + ), + + ( + "declare_reduction (+ : int : omp_out = omp_in + omp_out) initializer(omp_priv = omp_orig)", + tree.Initializer, + "initializer_stmt", + "omp_priv = omp_orig", + None + ), + ( + "declare_reduction (+ : int : omp_out = omp_in + omp_out) initializer(declare_reduction: omp_priv = omp_orig)", + tree.Initializer, + "initializer_stmt", + "omp_priv = omp_orig", + "declare_reduction" + ), + + ( + "declare_induction (+ : int) inductor(omp_var = 1+1) collector(omp_step * omp_idx + 1)", + tree.Inductor, + "inductor_stmt", + "omp_var = 1+1", + None + ), + ( + "declare_induction (+ : int) inductor(declare_induction: omp_var = 1+1) collector(declare_induction: omp_step * omp_idx + 1)", + tree.Inductor, + "inductor_stmt", + "omp_var = 1+1", + "declare_induction" + ), +]) +def test_stmt(source: str, clause_type: type[tree.DataScope], property: str, stmt: str, directive_name: str|None) -> None: + directive = parse(source) + clause = find_clause(directive, clause_type) + assert clause is not None + assert hasattr(clause, property) + assert getattr(clause, property).source == stmt + if directive_name is None: + assert clause.directive_name is None + else: + assert clause.directive_name is not None and clause.directive_name.string == directive_name + + +@pytest.mark.no_isolate +@pytest.mark.parametrize("source,clause_type,property,num,directive_name", [ + # collapse + ("simd aligned(x: 1)", tree.Aligned, "alignment_modifier", 1, None), + ("simd aligned(x: 4_2)", tree.Aligned, "alignment_modifier", 42, None), + ("simd aligned(x: 0b_11_11)", tree.Aligned, "alignment_modifier", 15, None), + ("simd aligned(x: 0B101)", tree.Aligned, "alignment_modifier", 5, None), + ("simd aligned(x: 0o_7_5_5)", tree.Aligned, "alignment_modifier", 493, None), + ("simd aligned(x: 0x1Ff)", tree.Aligned, "alignment_modifier", 511, None), + ("simd aligned(x: 0X1_0)", tree.Aligned, "alignment_modifier", 16, None), +]) +def test_integer(source: str, clause_type: type[tree.Clause], property: str, num: int, directive_name: str|None) -> None: + directive = parse(source) + clause = find_clause(directive, clause_type) + assert clause is not None + assert hasattr(clause, property) + assert getattr(clause, property).value == num + if directive_name is None: + assert clause.directive_name is None + else: + assert clause.directive_name is not None and clause.directive_name.string == directive_name + + +@pytest.mark.no_isolate +@pytest.mark.parametrize("source,clause_type,property,value,directive_name", [ + ("groupprivate device_type(host)", tree.DeviceType, "device_type_description", tree.DeviceType.Kind.HOST, None), +]) +def test_keyword_arg( + source: str, + clause_type: type[tree.Clause], + property: str, + value: int, + directive_name: str|None +) -> None: + directive = parse(source) + clause = find_clause(directive, clause_type) + assert clause is not None + assert hasattr(clause, property) + assert getattr(clause, property) == value + if directive_name is None: + assert clause.directive_name is None + else: + assert clause.directive_name is not None and clause.directive_name.string == directive_name + + +@pytest.mark.no_isolate +@pytest.mark.parametrize("source,clause_type,property,value,directive_name", [ + ( + "metadirective when(device={arch('nvptx')}: for private(abc))", + tree.When, + "directive", + "for", + None + ), + ( + "metadirective when(metadirective, device={arch('nvptx')}: for private(x))", + tree.When, + "directive", + "for", + "metadirective" + ), + + ( + """ + metadirective + when(device={arch('nvptx')}: for private(abc)), + otherwise(metadirective: for) + """, + tree.Otherwise, + "directive", + "for", + "metadirective" + ), +]) +def test_sub_directive( + source: str, + clause_type: type[tree.Clause], + property: str, + value: str|None, + directive_name: str|None +) -> None: + directive = parse(source) + clause = find_clause(directive, clause_type) + assert clause is not None + assert hasattr(clause, property) + if value is not None: + assert list(getattr(clause, property).constructs.keys())[0] == value + else: + assert len(getattr(clause, property).constructs) == 0 + if directive_name is None: + assert clause.directive_name is None + else: + assert clause.directive_name is not None and clause.directive_name.string == directive_name + + +#### CLAUSES WITH MODIFIERS #################################################### + +@pytest.mark.no_isolate +@pytest.mark.parametrize("source,clause_type,fields", [ + ( + "declare variant(var) match(device={arch('nvptx')})", + tree.Match, + [("context_selector", tree.ContextSelector)] + ), + ( + "declare variant(var) match(device={arch('nvptx')}) adjust_args(nothing: x, y)", + tree.AdjustArgs, + [("adjust_op_name", tree.Name)] + ), + ( + "declare variant(var) match(device={arch('nvptx')}) append_args(interop(target, target, targetsync))", + tree.AppendArgs, + [("append_op", tree.InteropModifier)] + ), + ( + "declare simd linear(x, y, z)", + tree.Linear, + [("targets", list)] + ), + ( + "declare target enter(x, y, z)", + tree.Enter, + [("targets", list)] + ), + ( + "declare target enter(automap: x, y, z)", + tree.Enter, + [("targets", list), ("automap_name", tree.Name)] + ), +]) +def test_clause_with_modifiers( + source: str, + clause_type: type[tree.Clause], + fields: list[tuple[str, type|None]], +) -> None: + directive = parse(source) + clause = find_clause(directive, clause_type) + assert clause is not None + + for field_name, field_type in fields: + assert hasattr(clause, field_name) + if field_type is not None: + assert isinstance(getattr(clause, field_name), field_type) + else: + assert getattr(clause, field_name) is None + diff --git a/test/parser/test_directives.py b/test/parser/test_directives.py new file mode 100644 index 0000000..3e43b4c --- /dev/null +++ b/test/parser/test_directives.py @@ -0,0 +1,527 @@ +from __future__ import annotations + +import inspect +import itertools +import types +import typing +from dataclasses import dataclass, field + +import pytest + +from omp4py.core.parser import tree, Parallel, Clause +from omp4py.core.parser.parser import _parse +from omp4py.core.parser.source_view import SourceView + + +#### HELPER FUNCTIONS ########################################################## + + +def parse(code: str) -> tree.Directive: + sv = SourceView( + tree.Span(0, 0, 0, 0), + "", + code.splitlines(), + code, + ) + return _parse(code, sv) + + +@dataclass +class ClauseInfo: + all: dict[str, type[tree.Clause]] = field(default_factory=dict) + required: dict[str, type[tree.Clause]] = field(default_factory=dict) + repeatable: dict[str, type[tree.Clause]] = field(default_factory=dict) + optional: dict[str, type[tree.Clause]] = field(default_factory=dict) + + + @staticmethod + def from_type(cls: type[tree.Construct], exclude: set[str]|None=None) -> ClauseInfo: + if exclude is None: + exclude = {"name", "span", "id", "directive_name"} + + clause_info = ClauseInfo() + for var_name, hint in typing.get_type_hints(cls).items(): + if var_name in exclude: + continue + + original_type = typing.get_origin(hint) + type_args = typing.get_args(hint) + + # If the type is something like list[Private] or list[Reduction], + # it means that this clause is repeatable. + if original_type is list and type_args and issubclass(type_args[0], tree.Clause): + clause_info.all[var_name] = type_args[0] + clause_info.repeatable[var_name] = type_args[0] + + # Otherwise, if the type is NoWait|None or Schedule|None, + # it means that this clause is not repeatable and optional + elif original_type is types.UnionType or original_type is typing.Union: + # Ignore the None types + non_none = [t for t in type_args if t is not type(None)] + # Check that the other type is actually a clause + if len(non_none) == 1 and isinstance(non_none[0], type) and issubclass(non_none[0], tree.Clause): + clause_info.all[var_name] = non_none[0] + clause_info.optional[var_name] = non_none[0] + + elif original_type is None and isinstance(hint, type) and issubclass(hint, tree.Clause): + clause_info.all[var_name] = hint + clause_info.required[var_name] = hint + + return clause_info + + @staticmethod + def merge(info1: ClauseInfo, info2: ClauseInfo) -> ClauseInfo: + return ClauseInfo( + all = {**info1.all, **info2.all}, + required = {**info1.required, **info2.required}, + repeatable = {**info1.repeatable, **info2.repeatable}, + optional = {**info1.optional, **info2.optional}, + ) + + def required_examples(self) -> list[str]: + return [CLAUSES[c] for c in self.required] + + def repeatable_examples(self) -> list[str]: + return [CLAUSES[c] for c in self.repeatable] + + def optional_examples(self) -> list[str]: + return [CLAUSES[c] for c in self.optional] + + def all_examples(self) -> list[str]: + return [CLAUSES[c] for c in self.all] + + + def required_joined(self, sep: str=" ") -> str: + return sep.join(self.required_examples()) + + def repeatable_joined(self, sep: str=" ") -> str: + return sep.join(self.repeatable_examples()) + + def optional_joined(self, sep: str=" ") -> str: + return sep.join(self.optional_examples()) + + def all_joined(self, sep: str=" ") -> str: + return sep.join(self.all_examples()) + + +@dataclass +class DirectiveSpec: + name: str + cls: type[tree.Construct] + clauses: ClauseInfo = field(init=False) + + def __post_init__(self) -> None: + object.__setattr__(self, "clauses", ClauseInfo.from_type(self.cls)) + + +#### CONSTANT DEFINITIONS ###################################################### + +CLAUSE_SEPARATORS = [",", ", ", ",\t", "\t", "\n"] +CLAUSES = { + "collapse": "collapse(2)", + "first_private": "firstprivate(x)", + "last_private": "lastprivate(x)", + "no_wait": "nowait", + "ordered": "ordered", + "private": "private(x)", + "reduction": "reduction(+:x)", + "schedule": "schedule(static)", + "shared": "shared(x)", + "num_threads": "num_threads(4)", + "if_": "if(True)", + "copyin": "copyin(x)", + "copyprivate": "copyprivate(x)", + "final": "final(True)", + "untied": "untied", + "mergeable": "mergeable", + "default": "default(none)", + "combiner": "combiner(omp_out = omp_out + omp_in)", + "initializer": "initializer(omp_priv = 0)", + "collector": "collector(omp_step * omp_idx)", + "inductor": "inductor(omp_var = omp_var + omp_step)", + + # metadirective + "when": "when(device={arch('nvptx')}: for private(abc))", + "otherwise": "otherwise(for)", + + # scan + "exclusive": "exclusive(x)", + "inclusive": "inclusive(x)", + "init_complete": "init_complete(True)", + + # groupprivate / declare_target + "device_type": "device_type(host)", + "enter": "enter(x)", + "indirect": "indirect(True)", + "link": "link(x)", + "local": "local(x)", + + # allocate + "align": "align(8)", + "allocator": "allocator(omp_default_mem_alloc)", + + # dispatch / declare_variant + "interop": "interop(x)", + "is_device_ptr": "is_device_ptr(x)", + "has_device_addr": "has_device_addr(x)", + "no_context": "nocontext(True)", + "no_variants": "novariants(True)", + "adjust_args": "adjust_args(nothing: x)", + "append_args": "append_args(interop(target))", + "match": "match(device={arch('nvptx')})", + + # declare_simd + "aligned": "aligned(x)", + "linear": "linear(x)", + "simdlen": "simdlen(8)", + "uniform": "uniform(x)", + "in_branch": "inbranch(True)", + "not_in_branch": "notinbranch(True)", + + # requires + "atomic_default_mem_order": "atomic_default_mem_order(seq_cst)", + "dynamic_allocators": "dynamic_allocators", + "reverse_offload": "reverse_offload", + "unified_address": "unified_address", + "unified_shared_memory": "unified_shared_memory", + "self_maps": "self_maps", + "device_safesync": "device_safesync", + + # assume (note: field name is misspelled in tree.py itself) + "absent": "absent(parallel)", + "contains": "contains(parallel)", + "holds": "holds(True)", + "no_openmp": "no_openmp", + "no_openmop_contructs": "no_openmp_constructs", + "no_openmp_routines": "no_openmp_routines", + "no_parallelism": "no_parallelism", + + # error + "at": "at(compilation)", + "message": 'message("msg")', + "severity": "severity(warning)", + + # fuse / interchange / split / stripe / tile / unroll + "apply": "apply(unroll)", + "looprange": "looprange(1, 2)", + "permutation": "permutation(1, 2)", + "counts": "counts(1, 2)", + "sizes": "sizes(4)", + "full": "full", + "partial": "partial", + + # parallel + "allocate": "allocate(x)", + "proc_bind": "proc_bind(spread)", + "safesync": "safesync(4)", + + # teams + "num_teams": "num_teams(4)", + "thread_limit": "thread_limit(4)", + + # simd / for / distribute + "non_temporal": "nontemporal(x)", + "order": "order(concurrent)", + "safelen": "safelen(4)", + "induction": "induction(+:i)", + "dist_schedule": "dist_schedule(static)", + + # masked + "filter": "filter(0)", + + # loop + "bind": "bind(thread)", + + # taskloop + "grain_size": "grain_size(4)", + "num_tasks": "num_tasks(4)", + "no_group": "nogroup", + + # taskgraph + "graph_id": "graph_id(1)", + "graph_reset": "graph_reset(True)", + + # target_data / target + "use_device_ptr": "use_device_ptr(x)", + "use_device_addr": "use_device_addr(x)", + "default_map": "defaultmap(none)", + "uses_allocators": "uses_allocators(omp_default_mem_alloc)", + "map": "map(to: x)", + "device": "device(0)", + "depobj_update": "update(x)", + "do_across": "doacross(sink: i = 0:10)", + + # target_update + "from_": "from(x)", + "to": "to(x)", + + # interop + "destroy": "destroy(x)", + "init": "init(x)", + "use": "use(x)", + "interop": "interop(x)", + + # critical / atomic / flush + "hint": "hint(0)", + "mem_scope": "memscope(device)", + "read": "read", + "update": "update", + "write": "write", + "capture": "capture", + "compare": "compare", + "fail": "fail(seq_cst)", + "weak": "weak", + "acq_rel": "acq_rel", + "acquire": "acquire", + "relaxed": "relaxed", + "release": "release", + "seq_cst": "seq_cst", + + # taskgroup + "task_reduction": "task_reduction(+:x)", + + # task + "affinity": "affinity(x)", + "depend": "depend(in: x)", + "detach": "detach(x)", + "in_reduction": "in_reduction(+:x)", + "priority": "priority(1)", + "replayable": "replayable(True)", + "thread_set": "thread_set(omp_pool)", + "transparent": "transparent(True)", + + # ordered + "simd": "simd", + "threads": "threads", +} + +# TODO: the commented directives require clauses of a group. +# This is enforced by the grammar (clause list cannot be empty) +# but cannot be represented in the dataclasses, +# because the type must be optional to handle the posibilities. +# These tests read from the classes, so they are not aware of this restrictions. +DIRECTIVES = [ + DirectiveSpec("threadprivate(x)", tree.ThreadPrivate), + #DirectiveSpec("declare_reduction(+:int)", tree.DeclareReduction), + #DirectiveSpec("declare_induction(+:int)", tree.DeclareInduction), + #DirectiveSpec("scan", tree.Scan), + #DirectiveSpec("declare_mapper(m: v: int)", tree.DeclareMapper), + DirectiveSpec("groupprivate", tree.GroupPrivate), + DirectiveSpec("allocate(x)", tree.Allocate), + DirectiveSpec("metadirective", tree.Metadirective), + DirectiveSpec("declare_variant(base:variant)", tree.DeclareVariant), + DirectiveSpec("dispatch", tree.Dispatch), + DirectiveSpec("declare_simd", tree.DeclareSimd), + DirectiveSpec("declare_target", tree.DeclareTarget), + #DirectiveSpec("requires", tree.Requires), + #DirectiveSpec("assume", tree.Assume), + DirectiveSpec("nothing", tree.Nothing), + DirectiveSpec("error", tree.Error), + #DirectiveSpec("fuse", tree.Fuse), + DirectiveSpec("interchange", tree.Interchange), + DirectiveSpec("reverse", tree.Reverse), + #DirectiveSpec("stripe", tree.Stripe), + #DirectiveSpec("tile", tree.Tile), + #DirectiveSpec("split", tree.Split), + DirectiveSpec("unroll", tree.Unroll), + DirectiveSpec("parallel", tree.Parallel), + DirectiveSpec("teams", tree.Teams), + DirectiveSpec("simd", tree.Simd), + DirectiveSpec("masked", tree.Masked), + DirectiveSpec("single", tree.Single), + DirectiveSpec("scope", tree.Scope), + DirectiveSpec("sections", tree.Sections), + DirectiveSpec("section", tree.Section), + DirectiveSpec("workshare", tree.Workshare), + DirectiveSpec("workdistribute", tree.Workdistribute), + DirectiveSpec("for", tree.For), + DirectiveSpec("distribute", tree.Distribute), + DirectiveSpec("loop", tree.Loop), + DirectiveSpec("task", tree.Task), + DirectiveSpec("taskloop", tree.Taskloop), + #DirectiveSpec("task_iteration", tree.TaskIteration), + DirectiveSpec("taskyield", tree.Taskyield), + DirectiveSpec("taskgraph", tree.Taskgraph), + #DirectiveSpec("target_data", tree.TargetData), + DirectiveSpec("target_enter_data", tree.TargetEnterData), + DirectiveSpec("target_exit_data", tree.TargetExitData), + DirectiveSpec("target", tree.Target), + DirectiveSpec("target_update", tree.TargetUpdate), + #DirectiveSpec("interop", tree.InteropConstruct), + DirectiveSpec("critical", tree.Critical), + DirectiveSpec("barrier", tree.Barrier), + DirectiveSpec("taskgroup", tree.Taskgroup), + DirectiveSpec("taskwait", tree.Taskwait), + #DirectiveSpec("atomic", tree.Atomic), + #DirectiveSpec("flush", tree.Flush), + #DirectiveSpec("depobj(x) destroy(x)", tree.Depobj), + DirectiveSpec("ordered", tree.Ordered), + DirectiveSpec("cancel parallel", tree.Cancel), + DirectiveSpec("cancellation_point parallel", tree.CancellationPoint), +] + + +#### EMPTY DIRECTIVES ########################################################## + + +@pytest.mark.no_isolate +@pytest.mark.parametrize("directive", DIRECTIVES) +def test_empty_directive(directive: DirectiveSpec) -> None: + source = directive.name + " " + directive.clauses.required_joined() + ast = parse(directive.name) + assert isinstance(ast.constructs[directive.cls.id], directive.cls) + + +#### DIRECTIVE WITH ALL CLAUSES ################################################ + + +@pytest.mark.no_isolate +@pytest.mark.parametrize("directive", DIRECTIVES) +def test_all_clauses(directive: DirectiveSpec) -> None: + source = directive.name + " " + directive.clauses.all_joined() + ast = parse(source) + assert isinstance(ast.constructs[directive.cls.id], directive.cls) + + +#### TEST CLAUSES WITH DIFFERENT SEPARATORS #################################### + + +def _gen_separator_cases() -> list[tuple[str, type]]: + cases = [] + for directive in DIRECTIVES: + clauses = directive.clauses.required_examples() + + # Use only the first 2 + if len(clauses) < 2: + clauses_set = set(clauses).union(set(directive.clauses.all_examples())) + if len(clauses_set) < 2: + continue + clauses = list(clauses_set) + + a, b = clauses[0], clauses[1] + cases.extend((f"{directive.name} {a}{sep}{b}", directive.cls) for sep in CLAUSE_SEPARATORS) + + return cases + +@pytest.mark.no_isolate +@pytest.mark.parametrize("source,construct_cls", _gen_separator_cases()) +def test_different_clause_separators(source: str, construct_cls: type[tree.Construct]) -> None: + ast = parse(source) + assert isinstance(ast.constructs[construct_cls.id], construct_cls) + + +#### TEST CHANGING THE CLAUSES' ORDER ########################################## + + +def _gen_ordering_cases(limit: int=10) -> list[tuple[str, type]]: + cases = [] + for directive in DIRECTIVES: + all_clauses = directive.clauses.all_examples() + if len(all_clauses) <= 1: + continue + for i, perm in enumerate(itertools.permutations(all_clauses)): + if i > limit: + break + cases.append((directive.name + " " + " ".join(perm), directive.cls)) + return cases + +@pytest.mark.no_isolate +@pytest.mark.parametrize("source,construct_cls", _gen_ordering_cases()) +def test_clause_ordering(source: str, construct_cls: type) -> None: + ast = parse(source) + assert isinstance(ast.constructs[construct_cls.id], construct_cls) + + +#### TEST REPEATED CLAUSES ##################################################### + + +def _gen_repeatable_cases(limit: int = 10) -> list[tuple[str, type, str]]: + return [ + (f"{directive.name} {directive.clauses.required_joined()} {CLAUSES[clause_key]} {CLAUSES[clause_key]}", directive.cls, clause_key) + for directive in DIRECTIVES + for i, clause_key in enumerate(directive.clauses.repeatable) + if i < limit + ] + +@pytest.mark.no_isolate +@pytest.mark.parametrize("source,construct_cls,field_name", _gen_repeatable_cases()) +def test_repeatable_clauses(source: str, construct_cls: type, field_name: str) -> None: + ast = parse(source) + assert isinstance(ast.constructs[construct_cls.id], construct_cls) + # verify both instances were collected, not just the last + assert len(getattr(ast.constructs[construct_cls.id], field_name)) == 2 + + +#### TEST NON-REPETEABLE CLAUSES RAISES AN ERROR ############################### + + +def _gen_non_repeatable_cases(limit: int = 10) -> list[str]: + return [ + f"{directive.name} {directive.clauses.required_joined()} {clause} {clause}" + for directive in DIRECTIVES + for i, clause in enumerate(directive.clauses.optional_examples()) + if i < limit + ] + +@pytest.mark.no_isolate +@pytest.mark.parametrize("source", _gen_non_repeatable_cases()) +def test_non_repeatable_clauses(source: str) -> None: + with pytest.raises(SyntaxError): + parse(source) + + +#### TEST INVALID CLAUSES FOR THIS DIRECTIVE ################################### + + +def _gen_wrong_directive_cases(limit: int = 10) -> list[str]: + all_clauses = set(CLAUSES) + return [ + f"{directive.name} {CLAUSES[clause]}" + for directive in DIRECTIVES + for i, clause in enumerate(all_clauses - set(directive.clauses.all)) + if clause in CLAUSES and i < limit + ] + +@pytest.mark.no_isolate +@pytest.mark.parametrize("source", _gen_wrong_directive_cases()) +def test_wrong_directive_clauses(source: str) -> None: + with pytest.raises(SyntaxError): + parse(source) + + +#### EMPTY DIRECTIVES ########################################################## + +COMBINED_DIRECTIVES = [ + DirectiveSpec("parallel", tree.Parallel), + DirectiveSpec("teams", tree.Teams), + DirectiveSpec("simd", tree.Simd), + DirectiveSpec("masked", tree.Masked), + DirectiveSpec("single", tree.Single), + DirectiveSpec("sections", tree.Single), + DirectiveSpec("workshare", tree.Workshare), + DirectiveSpec("workdistribute", tree.Workdistribute), + DirectiveSpec("for", tree.For), + DirectiveSpec("distribute", tree.Distribute), + DirectiveSpec("loop", tree.Loop), + DirectiveSpec("task", tree.Task), + DirectiveSpec("target_data", tree.TargetData), + DirectiveSpec("target_enter_data", tree.TargetEnterData), + DirectiveSpec("target_exit_data", tree.TargetExitData), + DirectiveSpec("target", tree.Target), + DirectiveSpec("target_update", tree.TargetUpdate), +] + +def _gen_combined_directives(limit: int = 10) -> list[str]: + return [ + f"{d1.name} {d2.name} {' '.join(set(d1.clauses.required_examples() + d2.clauses.required_examples()))}" + for i, (d1, d2) in enumerate(itertools.combinations(COMBINED_DIRECTIVES, 2)) + if i < limit + ] + +@pytest.mark.no_isolate +@pytest.mark.parametrize("directive", DIRECTIVES) +def test_combined_constructs(directive: DirectiveSpec) -> None: + source = directive.name + " " + directive.clauses.required_joined() + ast = parse(directive.name) + assert isinstance(ast.constructs[directive.cls.id], directive.cls) + diff --git a/test/parser/test_preprocesor.py b/test/parser/test_preprocesor.py new file mode 100644 index 0000000..bf8ff33 --- /dev/null +++ b/test/parser/test_preprocesor.py @@ -0,0 +1,118 @@ +from __future__ import annotations + +import pytest + +from omp4py.core.parser.parser import preprocesor + +CASES = [ + # Empty strings + ('""', " "*2), + ("''", " "*2), + ("''''''", " "*6), + ('""""""', " "*6), + ('r""""""', " "*7), + ('rb""""""', " "*8), + + # String prefixes + ('r"rub"', " rub "), + ('R"RUB"', " RUB "), + ('b""', " "*3), + ('B""', " "*3), + ('u""', " "*3), + ('U""', " "*3), + ('br""', " "*4), + ('Br""', " "*4), + ('bR""', " "*4), + ('BR""', " "*4), + ('rb""', " "*4), + ('rB""', " "*4), + ('Rb""', " "*4), + ('RB""', " "*4), + + # ANY: plain content, no escapes + ('"hello"', " hello "), + ("'hello'", " hello "), + ('"""hello"""', " hello "), + ("'''hello'''", " hello "), + ('"hello world"', " hello world "), + + # SINGLE_SCAPE_SEQ: recognized single-char escapes + (r'"\n"', " "*4), + (r'"\t"', " "*4), + (r'"\r"', " "*4), + (r'"\\"', " "*4), + (r'"\'"', " "*4), + (r'"\""', " "*4), + (r'"\a"', " "*4), + (r'"\b"', " "*4), + (r'"\f"', " "*4), + (r'"\v"', " "*4), + ('"\\\n"', " "*4), + + # OCTAL_SCAPE + (r'"\0"', " "*4), + (r'"\07"', " "*5), + (r'"\077"', " "*6), + + # HEX_SCAPE + (r'"\x00"', " "*6), + (r'"\x41"', " "*6), + (r'"\xff"', " "*6), + (r'"\xFF"', " "*6), + + # UNICODE_SCAPE: \uXXXX (4 hex digits) + (r'"\u0041"', " "*8), + (r'"\u00ff"', " "*8), + (r'"\uFFFF"', " "*8), + + # UNICODE_SCAPE: \UXXXXXXXX (8 hex digits) + (r'"\U00000041"', " "*12), + (r'"\U0001F600"', " "*12), + + # NAMED_UNICODE_SCAPE + (r'"\N{LATIN SMALL LETTER A}"', " "*26), + (r'"\N{snowman}"', " "*13), + (r'"\N{Greek Small Letter Alpha}"', " "*30), + + # UNRECOGNIZED_SCAPE_SEQ: unknown escapes pass through + (r'"\p"', r" \p "), + (r'"\q"', r" \q "), + (r'"\j"', r" \j "), + + # NEWLINE in triple-quoted strings + ('"""line1\nline2"""', " line1\nline2 "), + ("'''line1\nline2'''", " line1\nline2 "), + ('"""line1\n\nline2"""', " line1\n\nline2 "), + + # Quote characters allowed inside triple-quoted strings + ('"""she said "hi" """', ' she said "hi" '), + ("'''it's fine'''", " it's fine "), + ('"""one " two "" three"""', ' one " two "" three '), + ("'''one ' two '' three'''", " one ' two '' three "), + + # Opposite quote delimiter inside single-quoted strings + ('"it\'s"', " it's "), + ("'say \"hi\"'", ' say "hi" '), + + # Mixed content: ANY + escapes + (r'"hello\nworld"', " hello world "), + (r'"col:\x41end"', " col: end "), + (r'"a\tb\tc"', " a b c "), + + # Multiple escape sequences in a row + (r'"\n\t\r"', " " * 8), + (r'"\x41\x42"', " " * 10), + + # Triple-quoted with escapes + ('"""\\n"""', " " * 8), + ('"""\\x41"""', " " * 10), + ('b"""\\x41"""', " " * 11), + ('rb"""\\x41"""', " " * 12), +] + +@pytest.mark.no_isolate +@pytest.mark.parametrize("input,expected", CASES) +def test_string_preprocessor(input: str, expected: str) -> None: + content = preprocesor.parse(input) + assert len(content) == len(input) + assert content == expected