优化了yacc

inter/cfunc.c

@@ -1504,7 +1504,7 @@ GWARF_value to_str(GWARF_value value, var_list *the_var){
     return return_number;
 }
 
-// to str[底层实现]
+// dict key 带有类型的前缀
 GWARF_value to_str_dict(GWARF_value value, var_list *the_var){
     GWARF_value return_number;
     return_number.type = STRING_value;
@@ -1900,7 +1900,7 @@ GWARF_value to_dict(GWARF_value value, var_list *the_var){
     return_number.type = DICT_value;
 
     if(value.type == OBJECT_value){  // 调用__value__方法
-        return_number = to_list(get__value__(&value, the_var).value, the_var);  // 递归
+        return_number = to_dict(get__value__(&value, the_var).value, the_var);  // 递归
     }
     else{
         // 生成一个空的DICT
@@ -1974,7 +1974,7 @@ GWARF_value parameter_to_dict(parameter *tmp_s, var_list *the_var){  // 把param
     return_dict.value.dict_value->name_list = malloc(sizeof(dict_key));
     return_dict.value.dict_value->name_list->key = "";
     return_dict.value.dict_value->name_list->next = NULL;
-    
+
     int index = 0;
     GWARF_result result_tmp;
     while(1){
@@ -1982,6 +1982,7 @@ GWARF_value parameter_to_dict(parameter *tmp_s, var_list *the_var){  // 把param
             break;
         }
         if(tmp_s->type != name_value){
+            printf("tmp_s->type = %d\n", tmp_s->type);
             goto next;  // 跳过这一个
         }
         result_tmp = traverse(tmp_s->u.value, the_var, false);  // 不需要取__value__
@@ -1992,12 +1993,10 @@ GWARF_value parameter_to_dict(parameter *tmp_s, var_list *the_var){  // 把param
             goto next;
         }
 
-        char *key;;
-        size_t size = (size_t)(5 + strlen(tmp_s->u.name));
-        key = (char *)malloc(size);
-        snprintf(key, size,"str_%s", tmp_s->u.name);
+        GWARF_result key_tmp = traverse(tmp_s->u.var, the_var, 0);
+        char *key = to_str_dict(key_tmp.value, the_var).value.string;
 
-        int status = login_node(key, result_tmp.value, return_dict.value.dict_value->dict_value);  // 插入
+        login_node(key, result_tmp.value, return_dict.value.dict_value->dict_value);  // 插入
         dict_key *tmp_dict_name = return_dict.value.dict_value->name_list;
         while (1){  // 迭代
             if(!strcmp(tmp_dict_name->key, key)){  // 已经存在
@@ -2165,7 +2164,7 @@ GWARF_result dict_official_func(func *the_func, parameter *tmp_s, var_list *the_
                 GWARF_value base_the_var = tmp_result.value;  // 只有一个参数
                 get_value = get__value__(&base_the_var, the_var);
                 get_value.value = to_str_dict(get_value.value, out_var);
-                
+                printf("get_value.value.value.string = %s\n", get_value.value.value.string);
                 var *find_var = find_node(get_value.value.value.string, tmp->value.value.dict_value->dict_value);
                 if(find_var == NULL){  // not found
                     return_value = to_error("Dict key Not Found", "NameException", out_var);

inter/interpreter.c

@@ -1698,7 +1698,7 @@ GWARF_result assignment_statement(statement *the_statement, var_list *the_var, v
         value = assignment_func(left, right_result, login_var, from);
     }
     else if(the_statement->type == point){  // 通过point赋值
-        GWARF_result tmp_result = traverse(the_statement->code.point.base_var, the_var, false);  // 不用取value
+        GWARF_result tmp_result = traverse(the_statement->code.point.base_var, login_var, false);  // 不用取value
         if(is_error(&tmp_result)){  // Name Error错误
             // puts("STOP:: Name No Found!");
             return tmp_result;
@@ -1740,7 +1740,7 @@ GWARF_result assignment_statement(statement *the_statement, var_list *the_var, v
         }
     }
     else if(the_statement->type == down){  // 通过down赋值
-        GWARF_result tmp_result = traverse(the_statement->code.down.base_var, the_var, false), get;  // 不用取value
+        GWARF_result tmp_result = traverse(the_statement->code.down.base_var, login_var, false), get;  // 不用取value
         if(is_error(&tmp_result)){  // Name Error错误
             // puts("STOP:: Name No Found!");
             return tmp_result;
@@ -1827,7 +1827,7 @@ GWARF_result login_var(var_list *the_var, var_list *old_var_list, parameter *tmp
                         if(is_error(&tmp) || is_space(&tmp)){
                             return tmp;
                         }
-                        assignment_func(tmp_x->u.name, tmp, the_var, 0);
+                        assignment_statement(tmp_x->u.var, old_var_list,the_var, tmp);  // 赋值
                         tmp_x = tmp_x->next;  // get the next to iter
                     }
                     else if(tmp_x->type == put_args){  // args默认为[]
@@ -1838,7 +1838,7 @@ GWARF_result login_var(var_list *the_var, var_list *old_var_list, parameter *tmp
                         if(list_init != NULL){
                             func_result.value = list_init->value;
                         }
-                        assignment_func(tmp_x->u.name, call_back_core(func_result, old_var_list, NULL), the_var, 0);
+                        assignment_statement(tmp_x->u.var, old_var_list, the_var,call_back_core(func_result, old_var_list, NULL));  // old_var_list用于计算from等
                         tmp_x = tmp_x->next;  // get the next to iter
                     }
                     else{
@@ -1856,21 +1856,19 @@ GWARF_result login_var(var_list *the_var, var_list *old_var_list, parameter *tmp
                     if(tmp_x == NULL){
                         break;  // 形参录入完毕
                     }
-                    var *tmp_x_var = find_var(tmp_var, 0, tmp_x->u.name);
-                    if(tmp_x_var != NULL){
-                        GWARF_result tmp_result;
-                        tmp_result.value = tmp_x_var->value;
-                        assignment_func(tmp_x->u.name, tmp_result, the_var, 0);
+                    GWARF_result tmp_x_var = traverse(tmp_x->u.var, tmp_var, false);
+                    if((!is_error(&tmp_x_var)) && (!is_space(&tmp_x_var))){
+                        assignment_statement(tmp_x->u.var, old_var_list, the_var, tmp_x_var);
                     }
                     else if(tmp_x->type == name_value){
                         GWARF_result tmp = traverse(tmp_x->u.value, the_var, false);  // 执行形参
                         if(is_error(&tmp) || is_space(&tmp)){
                             return tmp;
                         }
-                        assignment_func(tmp_x->u.name, tmp, the_var, 0);
+                        assignment_statement(tmp_x->u.var, old_var_list, the_var, tmp);
                     }
                     else{
-                        printf("Warning!!!");
+                        printf("Warning!!!\n");
                         break;
                     }
                     tmp_x = tmp_x->next;
@@ -1893,7 +1891,7 @@ GWARF_result login_var(var_list *the_var, var_list *old_var_list, parameter *tmp
                 break;
             }
             assignment_type = 1;
-            assignment_func(tmp_s->u.name, tmp, tmp_var, 0);  // 先赋值到tmp_var上
+            assignment_statement(tmp_s->u.var, old_var_list, tmp_var, tmp);  // 先赋值到tmp_var上
             tmp_s = tmp_s->next;
         }
         else if(tmp_s->type == put_args){  // assignment_type不在1模式
@@ -1917,7 +1915,7 @@ GWARF_result login_var(var_list *the_var, var_list *old_var_list, parameter *tmp
             // 放入list中
             GWARF_result list_tmp;
             list_tmp.value = to_object(parameter_to_list(tmp_s, old_var_list), old_var_list);
-            assignment_func(tmp_x->u.name, list_tmp, the_var, 0);
+            assignment_statement(tmp_x->u.var, old_var_list, the_var, list_tmp);
             assignment_type = 1;  // 进入根据实参赋值模式
             tmp_x = tmp_x->next;
             while(1){
@@ -1931,7 +1929,7 @@ GWARF_result login_var(var_list *the_var, var_list *old_var_list, parameter *tmp
             }
         }
         else if(assignment_type == 0){
-            assignment_func(tmp_x->u.name, tmp, the_var, 0);
+            assignment_statement(tmp_x->u.var, old_var_list, the_var, tmp);
             tmp_x = tmp_x->next;  // get the next to iter
             tmp_s = tmp_s->next;
         }
@@ -1959,7 +1957,7 @@ GWARF_result call_back_core(GWARF_result get, var_list *the_var, parameter *tmp_
             if(func_->is_class){
                 if(get.father != NULL){
                     father.value = *(get.father);
-                    assignment_func(tmp_x->u.name, father, the_var, 0);
+                    assignment_statement(tmp_x->u.var, old_var_list, the_var, father);
                     tmp_x = tmp_x->next;  // get the next to iter
                 }
                 else{
@@ -2020,7 +2018,7 @@ GWARF_result call_back_core(GWARF_result get, var_list *the_var, parameter *tmp_
                 father.value.type = OBJECT_value;
                 father.value.value.object_value = object_tmp;
                 if(func_->is_class  == 1){
-                    assignment_func(tmp_x->u.name, father, the_var, 0);
+                    assignment_statement(tmp_x->u.var, old_var_list, the_var, father);
                     tmp_x = tmp_x->next;  // get the next to iter
                 }
 
@@ -2087,7 +2085,7 @@ GWARF_result call_back_core(GWARF_result get, var_list *the_var, parameter *tmp_
                 father.value.type = OBJECT_value;
                 father.value.value.object_value = get.value.value.object_value;
                 if(func_->is_class  == 1){
-                    assignment_func(tmp_x->u.name, father, the_var, 0);
+                    assignment_statement(tmp_x->u.var, old_var_list, the_var, father);
                     tmp_x = tmp_x->next;  // get the next to iter
                 }
 

inter/interpreter.h

@@ -49,7 +49,7 @@ typedef struct GWARF_value{
 typedef struct parameter{
     struct
     {
-        char *name;  // var name
+        struct statement *var;  // the_var
         struct statement *value;  // var value
     } u;
     enum {
@@ -647,8 +647,8 @@ unsigned int time33(char *);
 int login_node(char *, GWARF_value, hash_var *);
 var *find_node(char *, hash_var *);
 
-parameter *make_parameter_name(char *);
-parameter *append_parameter_name(char *, parameter *);
+parameter *make_parameter_name(statement *);
+parameter *append_parameter_name(statement *, parameter *);
 
 parameter *make_parameter_value(statement *);
 parameter *append_parameter_value(statement *, parameter *);

inter/parameter.c

@@ -2,17 +2,16 @@
 
 #include "interpreter.h"
 
-parameter *make_parameter_name(char *name){
+parameter *make_parameter_name(statement *var){
     parameter *tmp;
     tmp = malloc(sizeof(parameter));  // get an address for base var
     tmp->next = NULL;
-    tmp->u.name = malloc(sizeof(name));
+    tmp->u.var = var;
     tmp->type = only_name;
-    strcpy(tmp->u.name, name);
     return tmp;
 }
 
-parameter *append_parameter_name(char *name, parameter *parameter_base){
+parameter *append_parameter_name(statement *var, parameter *parameter_base){
     parameter *tmp = parameter_base;  // iter var
     while(1){
         if (tmp->next == NULL){  // the last
@@ -20,7 +19,7 @@ parameter *append_parameter_name(char *name, parameter *parameter_base){
         }
         tmp = tmp->next;  // get the next to iter
     }
-    parameter *new_tmp = make_parameter_name(name);
+    parameter *new_tmp = make_parameter_name(var);
     tmp->next = new_tmp;
     return new_tmp;
 }

paser/y.output

@@ -0,0 +1,6766 @@
+终端机在文法中未使用
+
+    INDENTA
+    AADD
+    ASUB
+    AMUL
+    ADIV
+    AMOD
+    AINTDIV
+    FADD
+    FSUB
+    APOW
+
+
+状态 43冲突：1 项偏移/归约
+状态 44冲突：1 项偏移/归约
+状态 55冲突：1 项偏移/归约
+状态 62冲突：1 项偏移/归约
+状态 68冲突：1 项偏移/归约
+状态 109冲突：1 项偏移/归约
+状态 120冲突：1 项偏移/归约
+状态 240冲突：1 项偏移/归约
+状态 245冲突：1 项偏移/归约
+状态 258冲突：1 项偏移/归约
+状态 259冲突：1 项偏移/归约
+状态 298冲突：1 项偏移/归约
+状态 328冲突：1 项偏移/归约
+状态 330冲突：1 项偏移/归约
+
+
+语法
+
+    0 $accept: command_block $end
+
+    1 command_block: command_list
+
+    2 command_list: command
+    3             | command_list command
+
+    4 command: top_exp stop_token
+    5        | while_block stop_token
+    6        | if_block stop_token
+    7        | break_exp stop_token
+    8        | broken_exp stop_token
+    9        | continue_exp stop_token
+   10        | continued_exp stop_token
+   11        | restart_exp stop_token
+   12        | restarted_exp stop_token
+   13        | REGO stop_token
+   14        | REWENT stop_token
+   15        | default_token stop_token
+   16        | global_token stop_token
+   17        | for_block stop_token
+   18        | nonlocal_token stop_token
+   19        | block_block stop_token
+   20        | def_block stop_token
+   21        | return_exp stop_token
+   22        | class_block stop_token
+   23        | try_block stop_token
+   24        | raise_exp stop_token
+   25        | import_exp stop_token
+   26        | include_exp stop_token
+   27        | do_while_block stop_token
+
+   28 top_exp: eq_number
+
+   29 eq_number: call_number
+   30          | eq_number EQ call_number
+
+   31 formal_parameter: top_exp
+   32                 | MUL top_exp
+   33                 | top_exp EQ top_exp
+   34                 | formal_parameter COMMA top_exp
+   35                 | formal_parameter COMMA MUL top_exp
+   36                 | formal_parameter COMMA top_exp EQ top_exp
+
+   37 arguments: top_exp
+   38          | arguments COMMA top_exp
+   39          | base_var_ EQ top_exp
+   40          | arguments COMMA base_var_ EQ top_exp
+   41          | MUL top_exp
+
+   42 slice_arguments: slice_arguments_token
+   43                | slice_arguments slice_arguments_token
+   44                | slice_arguments top_exp
+
+   45 slice_arguments_token: top_exp COLON
+
+   46 call_number: lambda_exp
+   47            | call_number LB RB
+   48            | call_number LB arguments RB
+
+   49 lambda_exp: chose_exp
+   50           | LB RB LAMBDA chose_exp
+   51           | LB formal_parameter RB LAMBDA chose_exp
+
+   52 chose_exp: bool_or
+   53          | chose_exp IF chose_exp ELSE chose_exp
+
+   54 bool_or: bool_and
+   55        | bool_or OR bool_and
+
+   56 bool_and: bool_not
+   57         | bool_and AND bool_not
+
+   58 bool_not: third_number
+   59         | NOT third_number
+
+   60 third_number: bit_or_not
+   61             | third_number EQUAL bit_or_not
+   62             | third_number MORE bit_or_not
+   63             | third_number LESS bit_or_not
+   64             | third_number MOREEQ bit_or_not
+   65             | third_number LESSEQ bit_or_not
+   66             | third_number NOTEQ bit_or_not
+
+   67 bit_or_not: bit_or
+   68           | bit_or_not BITNOTOR bit_or
+
+   69 bit_or: bit_and
+   70       | bit_or BITOR bit_and
+
+   71 bit_and: bit_move
+   72        | bit_and BITAND bit_move
+
+   73 bit_move: second_number
+   74         | bit_move BITRIGHT second_number
+   75         | bit_move BITLEFT second_number
+
+   76 second_number: first_number
+   77              | second_number ADD first_number
+   78              | second_number SUB first_number
+
+   79 first_number: negative
+   80             | first_number MUL negative
+   81             | first_number DIV negative
+   82             | first_number MOD negative
+   83             | first_number INTDIV negative
+
+   84 negative: bit_not
+   85         | SUB bit_not
+
+   86 bit_not: zero_number
+   87        | BITNOT zero_number
+
+   88 zero_number: attribute
+   89            | zero_number POW attribute
+   90            | zero_number LOG attribute
+   91            | zero_number SQRT attribute
+
+   92 attribute: call_down
+   93          | attribute POINT call_down
+
+   94 call_down: call_slice
+   95          | call_slice LI top_exp RI
+
+   96 call_slice: iter_value
+   97           | call_slice LI slice_arguments RI
+
+   98 iter_value: element
+   99           | LI list_arguments RI
+  100           | LP dict_arguments RP
+
+  101 list_arguments: top_exp
+  102               | list_arguments COMMA top_exp
+
+  103 dict_arguments: element EQ element
+  104               | dict_arguments COMMA element EQ element
+
+  105 element: base_value
+  106        | base_var_
+  107        | LB top_exp RB
+
+  108 base_value: NUMBER
+  109           | INT
+  110           | base_string
+  111           | TRUE
+  112           | FALSE
+  113           | NULL_token
+
+  114 base_var_: base_var_token
+  115          | LI top_exp RI base_var_token
+
+  116 base_var_token: VAR
+
+  117 base_string: STRING
+  118            | base_string STRING
+
+  119 nonlocal_token: NONLOCAL base_var_token
+
+  120 global_token: GLOBAL base_var_token
+
+  121 default_token: DEFAULT base_var_token element
+
+  122 return_exp: return_token
+  123           | return_token top_exp
+  124           | return_token top_exp element
+
+  125 return_token: RETURN
+
+  126 restarted_exp: restarted_token
+  127              | restarted_token element
+
+  128 restarted_token: RESTARTED
+
+  129 restart_exp: restart_token
+  130            | restart_token element
+
+  131 restart_token: RESTART
+
+  132 continued_exp: continued_token
+  133              | continued_token element
+
+  134 continued_token: CONTINUED
+
+  135 continue_exp: continue_token
+  136             | continue_token element
+
+  137 continue_token: CONTINUE
+
+  138 break_exp: break_token
+  139          | break_token element
+
+  140 break_token: BREAK
+
+  141 broken_exp: broken_token
+  142           | broken_token element
+
+  143 broken_token: BROKEN
+
+  144 if_block: if_exp block
+  145         | if_block elif_exp block
+
+  146 elif_exp: ELIF LB top_exp RB
+  147         | ELSE
+
+  148 if_exp: IF LB top_exp RB
+
+  149 block_block: block_exp block
+
+  150 block_exp: BLOCK
+
+  151 for_block: for_exp block
+
+  152 for_exp: FOR LB COMMA COMMA RB
+  153        | FOR LB top_exp COMMA COMMA RB
+  154        | FOR LB COMMA top_exp COMMA RB
+  155        | FOR LB COMMA COMMA top_exp RB
+  156        | FOR LB top_exp COMMA COMMA top_exp RB
+  157        | FOR LB top_exp COMMA top_exp COMMA RB
+  158        | FOR LB COMMA top_exp COMMA top_exp RB
+  159        | FOR LB top_exp COMMA top_exp COMMA top_exp RB
+  160        | FOR LB element IN top_exp RB
+
+  161 include_exp: INCLUDE top_exp
+
+  162 import_exp: IMPORT top_exp AS element
+
+  163 raise_exp: RAISE top_exp top_exp
+  164          | THROW top_exp
+  165          | ASSERT top_exp top_exp
+
+  166 try_block: try_exp block
+
+  167 try_exp: try_token block EXCEPT AS element
+
+  168 try_token: TRY
+
+  169 do_while_block: DO block while_exp
+  170               | DO block stop_token while_exp
+
+  171 while_block: while_exp block
+
+  172 while_exp: WHILE LB top_exp RB
+
+  173 class_block: class_exp block
+
+  174 class_exp: CLASS element LB RB
+  175          | CLASS element LB arguments RB
+
+  176 def_block: def_exp block
+
+  177 def_exp: DEF element LB RB
+  178        | DEF element LB formal_parameter RB
+
+  179 block: LP command_list RP
+  180      | LP block RP
+  181      | LP PASS RP
+
+  182 stop_token: STOPN
+  183           | STOPF
+  184           | stop_token STOPF
+  185           | stop_token STOPN
+
+
+终结语词，附有它们出现处的规则
+
+    $end (0) 0
+    error (256)
+    NUMBER <double_value> (258) 108
+    INT <double_value> (259) 109
+    STRING <string_value> (260) 117 118
+    VAR <string_value> (261) 116
+    ADD (262) 77
+    SUB (263) 78 85
+    DIV (264) 81
+    MUL (265) 32 35 41 80
+    EQ (266) 30 33 36 39 40 103 104
+    LESS (267) 63
+    MORE (268) 62
+    RB (269) 47 48 50 51 107 146 148 152 153 154 155 156 157 158 159 160 172 174 175 177 178
+    LB (270) 47 48 50 51 107 146 148 152 153 154 155 156 157 158 159 160 172 174 175 177 178
+    RP (271) 100 179 180 181
+    LP (272) 100 179 180 181
+    WHILE (273) 172
+    POW (274) 89
+    LOG (275) 90
+    SQRT (276) 91
+    EQUAL (277) 61
+    MOREEQ (278) 64
+    LESSEQ (279) 65
+    NOTEQ (280) 66
+    BREAK (281) 140
+    IF (282) 53 148
+    ELSE (283) 53 147
+    ELIF (284) 146
+    BROKEN (285) 143
+    CONTINUE (286) 137
+    CONTINUED (287) 134
+    RESTART (288) 131
+    RESTARTED (289) 128
+    REGO (290) 13
+    REWENT (291) 14
+    RI (292) 95 97 99 115
+    LI (293) 95 97 99 115
+    DEFAULT (294) 121
+    FOR (295) 152 153 154 155 156 157 158 159 160
+    COMMA (296) 34 35 36 38 40 102 104 152 153 154 155 156 157 158 159
+    GLOBAL (297) 120
+    NONLOCAL (298) 119
+    INDENTA (299)
+    STOPN (300) 182 185
+    STOPF (301) 183 184
+    BLOCK (302) 150
+    FALSE (303) 112
+    TRUE (304) 111
+    NULL_token (305) 113
+    DEF (306) 177 178
+    RETURN (307) 125
+    CLASS (308) 174 175
+    POINT (309) 93
+    COLON (310) 45
+    TRY (311) 168
+    EXCEPT (312) 167
+    AS (313) 162 167
+    RAISE (314) 163
+    THROW (315) 164
+    IMPORT (316) 162
+    INCLUDE (317) 161
+    IN (318) 160
+    AND (319) 57
+    OR (320) 55
+    NOT (321) 59
+    MOD (322) 82
+    INTDIV (323) 83
+    AADD (324)
+    ASUB (325)
+    AMUL (326)
+    ADIV (327)
+    AMOD (328)
+    AINTDIV (329)
+    FADD (330)
+    FSUB (331)
+    APOW (332)
+    BITAND (333) 72
+    BITOR (334) 70
+    BITNOT (335) 87
+    BITNOTOR (336) 68
+    BITRIGHT (337) 74
+    BITLEFT (338) 75
+    PASS (339) 181
+    DO (340) 169 170
+    LAMBDA (341) 50 51
+    ASSERT (342) 165
+
+
+非终结语词，附有它们出现处的规则
+
+    $accept (88)
+        on left: 0
+    command_block (89)
+        on left: 1
+        on right: 0
+    command_list (90)
+        on left: 2 3
+        on right: 1 3 179
+    command <statement_value> (91)
+        on left: 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
+        on right: 2 3
+    top_exp <statement_value> (92)
+        on left: 28
+        on right: 4 31 32 33 34 35 36 37 38 39 40 41 44 45 95 101 102 107 115 123 124 146 148 153 154 155 156 157 158 159 160 161 162 163 164 165 172
+    eq_number <statement_value> (93)
+        on left: 29 30
+        on right: 28 30
+    formal_parameter <parameter_list> (94)
+        on left: 31 32 33 34 35 36
+        on right: 34 35 36 51 178
+    arguments <parameter_list> (95)
+        on left: 37 38 39 40 41
+        on right: 38 40 48 175
+    slice_arguments <parameter_list> (96)
+        on left: 42 43 44
+        on right: 43 44 97
+    slice_arguments_token <statement_value> (97)
+        on left: 45
+        on right: 42 43
+    call_number <statement_value> (98)
+        on left: 46 47 48
+        on right: 29 30 47 48
+    lambda_exp <statement_value> (99)
+        on left: 49 50 51
+        on right: 46
+    chose_exp <statement_value> (100)
+        on left: 52 53
+        on right: 49 50 51 53
+    bool_or <statement_value> (101)
+        on left: 54 55
+        on right: 52 55
+    bool_and <statement_value> (102)
+        on left: 56 57
+        on right: 54 55 57
+    bool_not <statement_value> (103)
+        on left: 58 59
+        on right: 56 57
+    third_number <statement_value> (104)
+        on left: 60 61 62 63 64 65 66
+        on right: 58 59 61 62 63 64 65 66
+    bit_or_not <statement_value> (105)
+        on left: 67 68
+        on right: 60 61 62 63 64 65 66 68
+    bit_or <statement_value> (106)
+        on left: 69 70
+        on right: 67 68 70
+    bit_and <statement_value> (107)
+        on left: 71 72
+        on right: 69 70 72
+    bit_move <statement_value> (108)
+        on left: 73 74 75
+        on right: 71 72 74 75
+    second_number <statement_value> (109)
+        on left: 76 77 78
+        on right: 73 74 75 77 78
+    first_number <statement_value> (110)
+        on left: 79 80 81 82 83
+        on right: 76 77 78 80 81 82 83
+    negative <statement_value> (111)
+        on left: 84 85
+        on right: 79 80 81 82 83
+    bit_not <statement_value> (112)
+        on left: 86 87
+        on right: 84 85
+    zero_number <statement_value> (113)
+        on left: 88 89 90 91
+        on right: 86 87 89 90 91
+    attribute <statement_value> (114)
+        on left: 92 93
+        on right: 88 89 90 91 93
+    call_down <statement_value> (115)
+        on left: 94 95
+        on right: 92 93
+    call_slice <statement_value> (116)
+        on left: 96 97
+        on right: 94 95 97
+    iter_value <statement_value> (117)
+        on left: 98 99 100
+        on right: 96
+    list_arguments <parameter_list> (118)
+        on left: 101 102
+        on right: 99 102
+    dict_arguments <parameter_list> (119)
+        on left: 103 104
+        on right: 100 104
+    element <statement_value> (120)
+        on left: 105 106 107
+        on right: 98 103 104 121 124 127 130 133 136 139 142 160 162 167 174 175 177 178
+    base_value <statement_value> (121)
+        on left: 108 109 110 111 112 113
+        on right: 105
+    base_var_ <statement_value> (122)
+        on left: 114 115
+        on right: 39 40 106
+    base_var_token <statement_value> (123)
+        on left: 116
+        on right: 114 115 119 120 121
+    base_string <string_value> (124)
+        on left: 117 118
+        on right: 110 118
+    nonlocal_token <statement_value> (125)
+        on left: 119
+        on right: 18
+    global_token <statement_value> (126)
+        on left: 120
+        on right: 16
+    default_token <statement_value> (127)
+        on left: 121
+        on right: 15
+    return_exp <statement_value> (128)
+        on left: 122 123 124
+        on right: 21
+    return_token <statement_value> (129)
+        on left: 125
+        on right: 122 123 124
+    restarted_exp <statement_value> (130)
+        on left: 126 127
+        on right: 12
+    restarted_token <statement_value> (131)
+        on left: 128
+        on right: 126 127
+    restart_exp <statement_value> (132)
+        on left: 129 130
+        on right: 11
+    restart_token <statement_value> (133)
+        on left: 131
+        on right: 129 130
+    continued_exp <statement_value> (134)
+        on left: 132 133
+        on right: 10
+    continued_token <statement_value> (135)
+        on left: 134
+        on right: 132 133
+    continue_exp <statement_value> (136)
+        on left: 135 136
+        on right: 9
+    continue_token <statement_value> (137)
+        on left: 137
+        on right: 135 136
+    break_exp <statement_value> (138)
+        on left: 138 139
+        on right: 7
+    break_token <statement_value> (139)
+        on left: 140
+        on right: 138 139
+    broken_exp <statement_value> (140)
+        on left: 141 142
+        on right: 8
+    broken_token <statement_value> (141)
+        on left: 143
+        on right: 141 142
+    if_block <statement_value> (142)
+        on left: 144 145
+        on right: 6 145
+    elif_exp <if_list_base> (143)
+        on left: 146 147
+        on right: 145
+    if_exp <statement_value> (144)
+        on left: 148
+        on right: 144
+    block_block <statement_value> (145)
+        on left: 149
+        on right: 19
+    block_exp <statement_value> (146)
+        on left: 150
+        on right: 149
+    for_block <statement_value> (147)
+        on left: 151
+        on right: 17
+    for_exp <statement_value> (148)
+        on left: 152 153 154 155 156 157 158 159 160
+        on right: 151
+    include_exp <statement_value> (149)
+        on left: 161
+        on right: 26
+    import_exp <statement_value> (150)
+        on left: 162
+        on right: 25
+    raise_exp <statement_value> (151)
+        on left: 163 164 165
+        on right: 24
+    try_block <statement_value> (152)
+        on left: 166
+        on right: 23
+    try_exp <statement_value> (153)
+        on left: 167
+        on right: 166
+    try_token <statement_value> (154)
+        on left: 168
+        on right: 167
+    do_while_block <statement_value> (155)
+        on left: 169 170
+        on right: 27
+    while_block <statement_value> (156)
+        on left: 171
+        on right: 5
+    while_exp <statement_value> (157)
+        on left: 172
+        on right: 169 170 171
+    class_block <statement_value> (158)
+        on left: 173
+        on right: 22
+    class_exp <statement_value> (159)
+        on left: 174 175
+        on right: 173
+    def_block <statement_value> (160)
+        on left: 176
+        on right: 20
+    def_exp <statement_value> (161)
+        on left: 177 178
+        on right: 176
+    block (162)
+        on left: 179 180 181
+        on right: 144 145 149 151 166 167 169 170 171 173 176 180
+    stop_token (163)
+        on left: 182 183 184 185
+        on right: 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 170 184 185
+
+
+状态 0
+
+    0 $accept: . command_block $end
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    WHILE       偏移，并进入状态 8
+    BREAK       偏移，并进入状态 9
+    IF          偏移，并进入状态 10
+    BROKEN      偏移，并进入状态 11
+    CONTINUE    偏移，并进入状态 12
+    CONTINUED   偏移，并进入状态 13
+    RESTART     偏移，并进入状态 14
+    RESTARTED   偏移，并进入状态 15
+    REGO        偏移，并进入状态 16
+    REWENT      偏移，并进入状态 17
+    LI          偏移，并进入状态 18
+    DEFAULT     偏移，并进入状态 19
+    FOR         偏移，并进入状态 20
+    GLOBAL      偏移，并进入状态 21
+    NONLOCAL    偏移，并进入状态 22
+    BLOCK       偏移，并进入状态 23
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    DEF         偏移，并进入状态 27
+    RETURN      偏移，并进入状态 28
+    CLASS       偏移，并进入状态 29
+    TRY         偏移，并进入状态 30
+    RAISE       偏移，并进入状态 31
+    THROW       偏移，并进入状态 32
+    IMPORT      偏移，并进入状态 33
+    INCLUDE     偏移，并进入状态 34
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+    DO          偏移，并进入状态 37
+    ASSERT      偏移，并进入状态 38
+
+    command_block    转到状态 39
+    command_list     转到状态 40
+    command          转到状态 41
+    top_exp          转到状态 42
+    eq_number        转到状态 43
+    call_number      转到状态 44
+    lambda_exp       转到状态 45
+    chose_exp        转到状态 46
+    bool_or          转到状态 47
+    bool_and         转到状态 48
+    bool_not         转到状态 49
+    third_number     转到状态 50
+    bit_or_not       转到状态 51
+    bit_or           转到状态 52
+    bit_and          转到状态 53
+    bit_move         转到状态 54
+    second_number    转到状态 55
+    first_number     转到状态 56
+    negative         转到状态 57
+    bit_not          转到状态 58
+    zero_number      转到状态 59
+    attribute        转到状态 60
+    call_down        转到状态 61
+    call_slice       转到状态 62
+    iter_value       转到状态 63
+    element          转到状态 64
+    base_value       转到状态 65
+    base_var_        转到状态 66
+    base_var_token   转到状态 67
+    base_string      转到状态 68
+    nonlocal_token   转到状态 69
+    global_token     转到状态 70
+    default_token    转到状态 71
+    return_exp       转到状态 72
+    return_token     转到状态 73
+    restarted_exp    转到状态 74
+    restarted_token  转到状态 75
+    restart_exp      转到状态 76
+    restart_token    转到状态 77
+    continued_exp    转到状态 78
+    continued_token  转到状态 79
+    continue_exp     转到状态 80
+    continue_token   转到状态 81
+    break_exp        转到状态 82
+    break_token      转到状态 83
+    broken_exp       转到状态 84
+    broken_token     转到状态 85
+    if_block         转到状态 86
+    if_exp           转到状态 87
+    block_block      转到状态 88
+    block_exp        转到状态 89
+    for_block        转到状态 90
+    for_exp          转到状态 91
+    include_exp      转到状态 92
+    import_exp       转到状态 93
+    raise_exp        转到状态 94
+    try_block        转到状态 95
+    try_exp          转到状态 96
+    try_token        转到状态 97
+    do_while_block   转到状态 98
+    while_block      转到状态 99
+    while_exp        转到状态 100
+    class_block      转到状态 101
+    class_exp        转到状态 102
+    def_block        转到状态 103
+    def_exp          转到状态 104
+
+
+状态 1
+
+  108 base_value: NUMBER .
+
+    $default  使用规则 108 以归约 (base_value)
+
+
+状态 2
+
+  109 base_value: INT .
+
+    $default  使用规则 109 以归约 (base_value)
+
+
+状态 3
+
+  117 base_string: STRING .
+
+    $default  使用规则 117 以归约 (base_string)
+
+
+状态 4
+
+  116 base_var_token: VAR .
+
+    $default  使用规则 116 以归约 (base_var_token)
+
+
+状态 5
+
+   85 negative: SUB . bit_not
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    BITNOT      偏移，并进入状态 36
+
+    bit_not         转到状态 106
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 6
+
+   50 lambda_exp: LB . RB LAMBDA chose_exp
+   51           | LB . formal_parameter RB LAMBDA chose_exp
+  107 element: LB . top_exp RB
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    MUL         偏移，并进入状态 107
+    RB          偏移，并进入状态 108
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp           转到状态 109
+    eq_number         转到状态 43
+    formal_parameter  转到状态 110
+    call_number       转到状态 44
+    lambda_exp        转到状态 45
+    chose_exp         转到状态 46
+    bool_or           转到状态 47
+    bool_and          转到状态 48
+    bool_not          转到状态 49
+    third_number      转到状态 50
+    bit_or_not        转到状态 51
+    bit_or            转到状态 52
+    bit_and           转到状态 53
+    bit_move          转到状态 54
+    second_number     转到状态 55
+    first_number      转到状态 56
+    negative          转到状态 57
+    bit_not           转到状态 58
+    zero_number       转到状态 59
+    attribute         转到状态 60
+    call_down         转到状态 61
+    call_slice        转到状态 62
+    iter_value        转到状态 63
+    element           转到状态 64
+    base_value        转到状态 65
+    base_var_         转到状态 66
+    base_var_token    转到状态 67
+    base_string       转到状态 68
+
+
+状态 7
+
+  100 iter_value: LP . dict_arguments RP
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LI          偏移，并进入状态 111
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    dict_arguments  转到状态 112
+    element         转到状态 113
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 8
+
+  172 while_exp: WHILE . LB top_exp RB
+
+    LB  偏移，并进入状态 114
+
+
+状态 9
+
+  140 break_token: BREAK .
+
+    $default  使用规则 140 以归约 (break_token)
+
+
+状态 10
+
+  148 if_exp: IF . LB top_exp RB
+
+    LB  偏移，并进入状态 115
+
+
+状态 11
+
+  143 broken_token: BROKEN .
+
+    $default  使用规则 143 以归约 (broken_token)
+
+
+状态 12
+
+  137 continue_token: CONTINUE .
+
+    $default  使用规则 137 以归约 (continue_token)
+
+
+状态 13
+
+  134 continued_token: CONTINUED .
+
+    $default  使用规则 134 以归约 (continued_token)
+
+
+状态 14
+
+  131 restart_token: RESTART .
+
+    $default  使用规则 131 以归约 (restart_token)
+
+
+状态 15
+
+  128 restarted_token: RESTARTED .
+
+    $default  使用规则 128 以归约 (restarted_token)
+
+
+状态 16
+
+   13 command: REGO . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 118
+
+
+状态 17
+
+   14 command: REWENT . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 119
+
+
+状态 18
+
+   99 iter_value: LI . list_arguments RI
+  115 base_var_: LI . top_exp RI base_var_token
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 120
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    list_arguments  转到状态 121
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 19
+
+  121 default_token: DEFAULT . base_var_token element
+
+    VAR  偏移，并进入状态 4
+
+    base_var_token  转到状态 122
+
+
+状态 20
+
+  152 for_exp: FOR . LB COMMA COMMA RB
+  153        | FOR . LB top_exp COMMA COMMA RB
+  154        | FOR . LB COMMA top_exp COMMA RB
+  155        | FOR . LB COMMA COMMA top_exp RB
+  156        | FOR . LB top_exp COMMA COMMA top_exp RB
+  157        | FOR . LB top_exp COMMA top_exp COMMA RB
+  158        | FOR . LB COMMA top_exp COMMA top_exp RB
+  159        | FOR . LB top_exp COMMA top_exp COMMA top_exp RB
+  160        | FOR . LB element IN top_exp RB
+
+    LB  偏移，并进入状态 123
+
+
+状态 21
+
+  120 global_token: GLOBAL . base_var_token
+
+    VAR  偏移，并进入状态 4
+
+    base_var_token  转到状态 124
+
+
+状态 22
+
+  119 nonlocal_token: NONLOCAL . base_var_token
+
+    VAR  偏移，并进入状态 4
+
+    base_var_token  转到状态 125
+
+
+状态 23
+
+  150 block_exp: BLOCK .
+
+    $default  使用规则 150 以归约 (block_exp)
+
+
+状态 24
+
+  112 base_value: FALSE .
+
+    $default  使用规则 112 以归约 (base_value)
+
+
+状态 25
+
+  111 base_value: TRUE .
+
+    $default  使用规则 111 以归约 (base_value)
+
+
+状态 26
+
+  113 base_value: NULL_token .
+
+    $default  使用规则 113 以归约 (base_value)
+
+
+状态 27
+
+  177 def_exp: DEF . element LB RB
+  178        | DEF . element LB formal_parameter RB
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LI          偏移，并进入状态 111
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    element         转到状态 126
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 28
+
+  125 return_token: RETURN .
+
+    $default  使用规则 125 以归约 (return_token)
+
+
+状态 29
+
+  174 class_exp: CLASS . element LB RB
+  175          | CLASS . element LB arguments RB
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LI          偏移，并进入状态 111
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    element         转到状态 127
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 30
+
+  168 try_token: TRY .
+
+    $default  使用规则 168 以归约 (try_token)
+
+
+状态 31
+
+  163 raise_exp: RAISE . top_exp top_exp
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 128
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 32
+
+  164 raise_exp: THROW . top_exp
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 129
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 33
+
+  162 import_exp: IMPORT . top_exp AS element
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 130
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 34
+
+  161 include_exp: INCLUDE . top_exp
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 131
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 35
+
+   59 bool_not: NOT . third_number
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    BITNOT      偏移，并进入状态 36
+
+    third_number    转到状态 132
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 36
+
+   87 bit_not: BITNOT . zero_number
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    zero_number     转到状态 133
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 37
+
+  169 do_while_block: DO . block while_exp
+  170               | DO . block stop_token while_exp
+
+    LP  偏移，并进入状态 134
+
+    block  转到状态 135
+
+
+状态 38
+
+  165 raise_exp: ASSERT . top_exp top_exp
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 136
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 39
+
+    0 $accept: command_block . $end
+
+    $end  偏移，并进入状态 137
+
+
+状态 40
+
+    1 command_block: command_list .
+    3 command_list: command_list . command
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    WHILE       偏移，并进入状态 8
+    BREAK       偏移，并进入状态 9
+    IF          偏移，并进入状态 10
+    BROKEN      偏移，并进入状态 11
+    CONTINUE    偏移，并进入状态 12
+    CONTINUED   偏移，并进入状态 13
+    RESTART     偏移，并进入状态 14
+    RESTARTED   偏移，并进入状态 15
+    REGO        偏移，并进入状态 16
+    REWENT      偏移，并进入状态 17
+    LI          偏移，并进入状态 18
+    DEFAULT     偏移，并进入状态 19
+    FOR         偏移，并进入状态 20
+    GLOBAL      偏移，并进入状态 21
+    NONLOCAL    偏移，并进入状态 22
+    BLOCK       偏移，并进入状态 23
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    DEF         偏移，并进入状态 27
+    RETURN      偏移，并进入状态 28
+    CLASS       偏移，并进入状态 29
+    TRY         偏移，并进入状态 30
+    RAISE       偏移，并进入状态 31
+    THROW       偏移，并进入状态 32
+    IMPORT      偏移，并进入状态 33
+    INCLUDE     偏移，并进入状态 34
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+    DO          偏移，并进入状态 37
+    ASSERT      偏移，并进入状态 38
+
+    $default  使用规则 1 以归约 (command_block)
+
+    command          转到状态 138
+    top_exp          转到状态 42
+    eq_number        转到状态 43
+    call_number      转到状态 44
+    lambda_exp       转到状态 45
+    chose_exp        转到状态 46
+    bool_or          转到状态 47
+    bool_and         转到状态 48
+    bool_not         转到状态 49
+    third_number     转到状态 50
+    bit_or_not       转到状态 51
+    bit_or           转到状态 52
+    bit_and          转到状态 53
+    bit_move         转到状态 54
+    second_number    转到状态 55
+    first_number     转到状态 56
+    negative         转到状态 57
+    bit_not          转到状态 58
+    zero_number      转到状态 59
+    attribute        转到状态 60
+    call_down        转到状态 61
+    call_slice       转到状态 62
+    iter_value       转到状态 63
+    element          转到状态 64
+    base_value       转到状态 65
+    base_var_        转到状态 66
+    base_var_token   转到状态 67
+    base_string      转到状态 68
+    nonlocal_token   转到状态 69
+    global_token     转到状态 70
+    default_token    转到状态 71
+    return_exp       转到状态 72
+    return_token     转到状态 73
+    restarted_exp    转到状态 74
+    restarted_token  转到状态 75
+    restart_exp      转到状态 76
+    restart_token    转到状态 77
+    continued_exp    转到状态 78
+    continued_token  转到状态 79
+    continue_exp     转到状态 80
+    continue_token   转到状态 81
+    break_exp        转到状态 82
+    break_token      转到状态 83
+    broken_exp       转到状态 84
+    broken_token     转到状态 85
+    if_block         转到状态 86
+    if_exp           转到状态 87
+    block_block      转到状态 88
+    block_exp        转到状态 89
+    for_block        转到状态 90
+    for_exp          转到状态 91
+    include_exp      转到状态 92
+    import_exp       转到状态 93
+    raise_exp        转到状态 94
+    try_block        转到状态 95
+    try_exp          转到状态 96
+    try_token        转到状态 97
+    do_while_block   转到状态 98
+    while_block      转到状态 99
+    while_exp        转到状态 100
+    class_block      转到状态 101
+    class_exp        转到状态 102
+    def_block        转到状态 103
+    def_exp          转到状态 104
+
+
+状态 41
+
+    2 command_list: command .
+
+    $default  使用规则 2 以归约 (command_list)
+
+
+状态 42
+
+    4 command: top_exp . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 139
+
+
+状态 43
+
+   28 top_exp: eq_number .
+   30 eq_number: eq_number . EQ call_number
+
+    EQ  偏移，并进入状态 140
+
+    EQ        [使用规则 28 以归约 (top_exp)]
+    $default  使用规则 28 以归约 (top_exp)
+
+
+状态 44
+
+   29 eq_number: call_number .
+   47 call_number: call_number . LB RB
+   48            | call_number . LB arguments RB
+
+    LB  偏移，并进入状态 141
+
+    LB        [使用规则 29 以归约 (eq_number)]
+    $default  使用规则 29 以归约 (eq_number)
+
+
+状态 45
+
+   46 call_number: lambda_exp .
+
+    $default  使用规则 46 以归约 (call_number)
+
+
+状态 46
+
+   49 lambda_exp: chose_exp .
+   53 chose_exp: chose_exp . IF chose_exp ELSE chose_exp
+
+    IF  偏移，并进入状态 142
+
+    $default  使用规则 49 以归约 (lambda_exp)
+
+
+状态 47
+
+   52 chose_exp: bool_or .
+   55 bool_or: bool_or . OR bool_and
+
+    OR  偏移，并进入状态 143
+
+    $default  使用规则 52 以归约 (chose_exp)
+
+
+状态 48
+
+   54 bool_or: bool_and .
+   57 bool_and: bool_and . AND bool_not
+
+    AND  偏移，并进入状态 144
+
+    $default  使用规则 54 以归约 (bool_or)
+
+
+状态 49
+
+   56 bool_and: bool_not .
+
+    $default  使用规则 56 以归约 (bool_and)
+
+
+状态 50
+
+   58 bool_not: third_number .
+   61 third_number: third_number . EQUAL bit_or_not
+   62             | third_number . MORE bit_or_not
+   63             | third_number . LESS bit_or_not
+   64             | third_number . MOREEQ bit_or_not
+   65             | third_number . LESSEQ bit_or_not
+   66             | third_number . NOTEQ bit_or_not
+
+    LESS    偏移，并进入状态 145
+    MORE    偏移，并进入状态 146
+    EQUAL   偏移，并进入状态 147
+    MOREEQ  偏移，并进入状态 148
+    LESSEQ  偏移，并进入状态 149
+    NOTEQ   偏移，并进入状态 150
+
+    $default  使用规则 58 以归约 (bool_not)
+
+
+状态 51
+
+   60 third_number: bit_or_not .
+   68 bit_or_not: bit_or_not . BITNOTOR bit_or
+
+    BITNOTOR  偏移，并进入状态 151
+
+    $default  使用规则 60 以归约 (third_number)
+
+
+状态 52
+
+   67 bit_or_not: bit_or .
+   70 bit_or: bit_or . BITOR bit_and
+
+    BITOR  偏移，并进入状态 152
+
+    $default  使用规则 67 以归约 (bit_or_not)
+
+
+状态 53
+
+   69 bit_or: bit_and .
+   72 bit_and: bit_and . BITAND bit_move
+
+    BITAND  偏移，并进入状态 153
+
+    $default  使用规则 69 以归约 (bit_or)
+
+
+状态 54
+
+   71 bit_and: bit_move .
+   74 bit_move: bit_move . BITRIGHT second_number
+   75         | bit_move . BITLEFT second_number
+
+    BITRIGHT  偏移，并进入状态 154
+    BITLEFT   偏移，并进入状态 155
+
+    $default  使用规则 71 以归约 (bit_and)
+
+
+状态 55
+
+   73 bit_move: second_number .
+   77 second_number: second_number . ADD first_number
+   78              | second_number . SUB first_number
+
+    ADD  偏移，并进入状态 156
+    SUB  偏移，并进入状态 157
+
+    SUB       [使用规则 73 以归约 (bit_move)]
+    $default  使用规则 73 以归约 (bit_move)
+
+
+状态 56
+
+   76 second_number: first_number .
+   80 first_number: first_number . MUL negative
+   81             | first_number . DIV negative
+   82             | first_number . MOD negative
+   83             | first_number . INTDIV negative
+
+    DIV     偏移，并进入状态 158
+    MUL     偏移，并进入状态 159
+    MOD     偏移，并进入状态 160
+    INTDIV  偏移，并进入状态 161
+
+    $default  使用规则 76 以归约 (second_number)
+
+
+状态 57
+
+   79 first_number: negative .
+
+    $default  使用规则 79 以归约 (first_number)
+
+
+状态 58
+
+   84 negative: bit_not .
+
+    $default  使用规则 84 以归约 (negative)
+
+
+状态 59
+
+   86 bit_not: zero_number .
+   89 zero_number: zero_number . POW attribute
+   90            | zero_number . LOG attribute
+   91            | zero_number . SQRT attribute
+
+    POW   偏移，并进入状态 162
+    LOG   偏移，并进入状态 163
+    SQRT  偏移，并进入状态 164
+
+    $default  使用规则 86 以归约 (bit_not)
+
+
+状态 60
+
+   88 zero_number: attribute .
+   93 attribute: attribute . POINT call_down
+
+    POINT  偏移，并进入状态 165
+
+    $default  使用规则 88 以归约 (zero_number)
+
+
+状态 61
+
+   92 attribute: call_down .
+
+    $default  使用规则 92 以归约 (attribute)
+
+
+状态 62
+
+   94 call_down: call_slice .
+   95          | call_slice . LI top_exp RI
+   97 call_slice: call_slice . LI slice_arguments RI
+
+    LI  偏移，并进入状态 166
+
+    LI        [使用规则 94 以归约 (call_down)]
+    $default  使用规则 94 以归约 (call_down)
+
+
+状态 63
+
+   96 call_slice: iter_value .
+
+    $default  使用规则 96 以归约 (call_slice)
+
+
+状态 64
+
+   98 iter_value: element .
+
+    $default  使用规则 98 以归约 (iter_value)
+
+
+状态 65
+
+  105 element: base_value .
+
+    $default  使用规则 105 以归约 (element)
+
+
+状态 66
+
+  106 element: base_var_ .
+
+    $default  使用规则 106 以归约 (element)
+
+
+状态 67
+
+  114 base_var_: base_var_token .
+
+    $default  使用规则 114 以归约 (base_var_)
+
+
+状态 68
+
+  110 base_value: base_string .
+  118 base_string: base_string . STRING
+
+    STRING  偏移，并进入状态 167
+
+    STRING    [使用规则 110 以归约 (base_value)]
+    $default  使用规则 110 以归约 (base_value)
+
+
+状态 69
+
+   18 command: nonlocal_token . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 168
+
+
+状态 70
+
+   16 command: global_token . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 169
+
+
+状态 71
+
+   15 command: default_token . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 170
+
+
+状态 72
+
+   21 command: return_exp . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 171
+
+
+状态 73
+
+  122 return_exp: return_token .
+  123           | return_token . top_exp
+  124           | return_token . top_exp element
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    $default  使用规则 122 以归约 (return_exp)
+
+    top_exp         转到状态 172
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 74
+
+   12 command: restarted_exp . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 173
+
+
+状态 75
+
+  126 restarted_exp: restarted_token .
+  127              | restarted_token . element
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LI          偏移，并进入状态 111
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    $default  使用规则 126 以归约 (restarted_exp)
+
+    element         转到状态 174
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 76
+
+   11 command: restart_exp . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 175
+
+
+状态 77
+
+  129 restart_exp: restart_token .
+  130            | restart_token . element
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LI          偏移，并进入状态 111
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    $default  使用规则 129 以归约 (restart_exp)
+
+    element         转到状态 176
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 78
+
+   10 command: continued_exp . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 177
+
+
+状态 79
+
+  132 continued_exp: continued_token .
+  133              | continued_token . element
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LI          偏移，并进入状态 111
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    $default  使用规则 132 以归约 (continued_exp)
+
+    element         转到状态 178
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 80
+
+    9 command: continue_exp . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 179
+
+
+状态 81
+
+  135 continue_exp: continue_token .
+  136             | continue_token . element
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LI          偏移，并进入状态 111
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    $default  使用规则 135 以归约 (continue_exp)
+
+    element         转到状态 180
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 82
+
+    7 command: break_exp . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 181
+
+
+状态 83
+
+  138 break_exp: break_token .
+  139          | break_token . element
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LI          偏移，并进入状态 111
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    $default  使用规则 138 以归约 (break_exp)
+
+    element         转到状态 182
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 84
+
+    8 command: broken_exp . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 183
+
+
+状态 85
+
+  141 broken_exp: broken_token .
+  142           | broken_token . element
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LI          偏移，并进入状态 111
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    $default  使用规则 141 以归约 (broken_exp)
+
+    element         转到状态 184
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 86
+
+    6 command: if_block . stop_token
+  145 if_block: if_block . elif_exp block
+
+    ELSE   偏移，并进入状态 185
+    ELIF   偏移，并进入状态 186
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    elif_exp    转到状态 187
+    stop_token  转到状态 188
+
+
+状态 87
+
+  144 if_block: if_exp . block
+
+    LP  偏移，并进入状态 134
+
+    block  转到状态 189
+
+
+状态 88
+
+   19 command: block_block . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 190
+
+
+状态 89
+
+  149 block_block: block_exp . block
+
+    LP  偏移，并进入状态 134
+
+    block  转到状态 191
+
+
+状态 90
+
+   17 command: for_block . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 192
+
+
+状态 91
+
+  151 for_block: for_exp . block
+
+    LP  偏移，并进入状态 134
+
+    block  转到状态 193
+
+
+状态 92
+
+   26 command: include_exp . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 194
+
+
+状态 93
+
+   25 command: import_exp . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 195
+
+
+状态 94
+
+   24 command: raise_exp . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 196
+
+
+状态 95
+
+   23 command: try_block . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 197
+
+
+状态 96
+
+  166 try_block: try_exp . block
+
+    LP  偏移，并进入状态 134
+
+    block  转到状态 198
+
+
+状态 97
+
+  167 try_exp: try_token . block EXCEPT AS element
+
+    LP  偏移，并进入状态 134
+
+    block  转到状态 199
+
+
+状态 98
+
+   27 command: do_while_block . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 200
+
+
+状态 99
+
+    5 command: while_block . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 201
+
+
+状态 100
+
+  171 while_block: while_exp . block
+
+    LP  偏移，并进入状态 134
+
+    block  转到状态 202
+
+
+状态 101
+
+   22 command: class_block . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 203
+
+
+状态 102
+
+  173 class_block: class_exp . block
+
+    LP  偏移，并进入状态 134
+
+    block  转到状态 204
+
+
+状态 103
+
+   20 command: def_block . stop_token
+
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    stop_token  转到状态 205
+
+
+状态 104
+
+  176 def_block: def_exp . block
+
+    LP  偏移，并进入状态 134
+
+    block  转到状态 206
+
+
+状态 105
+
+  107 element: LB . top_exp RB
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 207
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 106
+
+   85 negative: SUB bit_not .
+
+    $default  使用规则 85 以归约 (negative)
+
+
+状态 107
+
+   32 formal_parameter: MUL . top_exp
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 208
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 108
+
+   50 lambda_exp: LB RB . LAMBDA chose_exp
+
+    LAMBDA  偏移，并进入状态 209
+
+
+状态 109
+
+   31 formal_parameter: top_exp .
+   33                 | top_exp . EQ top_exp
+  107 element: LB top_exp . RB
+
+    EQ  偏移，并进入状态 210
+    RB  偏移，并进入状态 211
+
+    RB        [使用规则 31 以归约 (formal_parameter)]
+    $default  使用规则 31 以归约 (formal_parameter)
+
+
+状态 110
+
+   34 formal_parameter: formal_parameter . COMMA top_exp
+   35                 | formal_parameter . COMMA MUL top_exp
+   36                 | formal_parameter . COMMA top_exp EQ top_exp
+   51 lambda_exp: LB formal_parameter . RB LAMBDA chose_exp
+
+    RB     偏移，并进入状态 212
+    COMMA  偏移，并进入状态 213
+
+
+状态 111
+
+  115 base_var_: LI . top_exp RI base_var_token
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 214
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 112
+
+  100 iter_value: LP dict_arguments . RP
+  104 dict_arguments: dict_arguments . COMMA element EQ element
+
+    RP     偏移，并进入状态 215
+    COMMA  偏移，并进入状态 216
+
+
+状态 113
+
+  103 dict_arguments: element . EQ element
+
+    EQ  偏移，并进入状态 217
+
+
+状态 114
+
+  172 while_exp: WHILE LB . top_exp RB
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 218
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 115
+
+  148 if_exp: IF LB . top_exp RB
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 219
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 116
+
+  182 stop_token: STOPN .
+
+    $default  使用规则 182 以归约 (stop_token)
+
+
+状态 117
+
+  183 stop_token: STOPF .
+
+    $default  使用规则 183 以归约 (stop_token)
+
+
+状态 118
+
+   13 command: REGO stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 13 以归约 (command)
+
+
+状态 119
+
+   14 command: REWENT stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 14 以归约 (command)
+
+
+状态 120
+
+  101 list_arguments: top_exp .
+  115 base_var_: LI top_exp . RI base_var_token
+
+    RI  偏移，并进入状态 222
+
+    RI        [使用规则 101 以归约 (list_arguments)]
+    $default  使用规则 101 以归约 (list_arguments)
+
+
+状态 121
+
+   99 iter_value: LI list_arguments . RI
+  102 list_arguments: list_arguments . COMMA top_exp
+
+    RI     偏移，并进入状态 223
+    COMMA  偏移，并进入状态 224
+
+
+状态 122
+
+  121 default_token: DEFAULT base_var_token . element
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LI          偏移，并进入状态 111
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    element         转到状态 225
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 123
+
+  152 for_exp: FOR LB . COMMA COMMA RB
+  153        | FOR LB . top_exp COMMA COMMA RB
+  154        | FOR LB . COMMA top_exp COMMA RB
+  155        | FOR LB . COMMA COMMA top_exp RB
+  156        | FOR LB . top_exp COMMA COMMA top_exp RB
+  157        | FOR LB . top_exp COMMA top_exp COMMA RB
+  158        | FOR LB . COMMA top_exp COMMA top_exp RB
+  159        | FOR LB . top_exp COMMA top_exp COMMA top_exp RB
+  160        | FOR LB . element IN top_exp RB
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    COMMA       偏移，并进入状态 226
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 227
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 228
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 124
+
+  120 global_token: GLOBAL base_var_token .
+
+    $default  使用规则 120 以归约 (global_token)
+
+
+状态 125
+
+  119 nonlocal_token: NONLOCAL base_var_token .
+
+    $default  使用规则 119 以归约 (nonlocal_token)
+
+
+状态 126
+
+  177 def_exp: DEF element . LB RB
+  178        | DEF element . LB formal_parameter RB
+
+    LB  偏移，并进入状态 229
+
+
+状态 127
+
+  174 class_exp: CLASS element . LB RB
+  175          | CLASS element . LB arguments RB
+
+    LB  偏移，并进入状态 230
+
+
+状态 128
+
+  163 raise_exp: RAISE top_exp . top_exp
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 231
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 129
+
+  164 raise_exp: THROW top_exp .
+
+    $default  使用规则 164 以归约 (raise_exp)
+
+
+状态 130
+
+  162 import_exp: IMPORT top_exp . AS element
+
+    AS  偏移，并进入状态 232
+
+
+状态 131
+
+  161 include_exp: INCLUDE top_exp .
+
+    $default  使用规则 161 以归约 (include_exp)
+
+
+状态 132
+
+   59 bool_not: NOT third_number .
+   61 third_number: third_number . EQUAL bit_or_not
+   62             | third_number . MORE bit_or_not
+   63             | third_number . LESS bit_or_not
+   64             | third_number . MOREEQ bit_or_not
+   65             | third_number . LESSEQ bit_or_not
+   66             | third_number . NOTEQ bit_or_not
+
+    LESS    偏移，并进入状态 145
+    MORE    偏移，并进入状态 146
+    EQUAL   偏移，并进入状态 147
+    MOREEQ  偏移，并进入状态 148
+    LESSEQ  偏移，并进入状态 149
+    NOTEQ   偏移，并进入状态 150
+
+    $default  使用规则 59 以归约 (bool_not)
+
+
+状态 133
+
+   87 bit_not: BITNOT zero_number .
+   89 zero_number: zero_number . POW attribute
+   90            | zero_number . LOG attribute
+   91            | zero_number . SQRT attribute
+
+    POW   偏移，并进入状态 162
+    LOG   偏移，并进入状态 163
+    SQRT  偏移，并进入状态 164
+
+    $default  使用规则 87 以归约 (bit_not)
+
+
+状态 134
+
+  179 block: LP . command_list RP
+  180      | LP . block RP
+  181      | LP . PASS RP
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 233
+    WHILE       偏移，并进入状态 8
+    BREAK       偏移，并进入状态 9
+    IF          偏移，并进入状态 10
+    BROKEN      偏移，并进入状态 11
+    CONTINUE    偏移，并进入状态 12
+    CONTINUED   偏移，并进入状态 13
+    RESTART     偏移，并进入状态 14
+    RESTARTED   偏移，并进入状态 15
+    REGO        偏移，并进入状态 16
+    REWENT      偏移，并进入状态 17
+    LI          偏移，并进入状态 18
+    DEFAULT     偏移，并进入状态 19
+    FOR         偏移，并进入状态 20
+    GLOBAL      偏移，并进入状态 21
+    NONLOCAL    偏移，并进入状态 22
+    BLOCK       偏移，并进入状态 23
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    DEF         偏移，并进入状态 27
+    RETURN      偏移，并进入状态 28
+    CLASS       偏移，并进入状态 29
+    TRY         偏移，并进入状态 30
+    RAISE       偏移，并进入状态 31
+    THROW       偏移，并进入状态 32
+    IMPORT      偏移，并进入状态 33
+    INCLUDE     偏移，并进入状态 34
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+    PASS        偏移，并进入状态 234
+    DO          偏移，并进入状态 37
+    ASSERT      偏移，并进入状态 38
+
+    command_list     转到状态 235
+    command          转到状态 41
+    top_exp          转到状态 42
+    eq_number        转到状态 43
+    call_number      转到状态 44
+    lambda_exp       转到状态 45
+    chose_exp        转到状态 46
+    bool_or          转到状态 47
+    bool_and         转到状态 48
+    bool_not         转到状态 49
+    third_number     转到状态 50
+    bit_or_not       转到状态 51
+    bit_or           转到状态 52
+    bit_and          转到状态 53
+    bit_move         转到状态 54
+    second_number    转到状态 55
+    first_number     转到状态 56
+    negative         转到状态 57
+    bit_not          转到状态 58
+    zero_number      转到状态 59
+    attribute        转到状态 60
+    call_down        转到状态 61
+    call_slice       转到状态 62
+    iter_value       转到状态 63
+    element          转到状态 64
+    base_value       转到状态 65
+    base_var_        转到状态 66
+    base_var_token   转到状态 67
+    base_string      转到状态 68
+    nonlocal_token   转到状态 69
+    global_token     转到状态 70
+    default_token    转到状态 71
+    return_exp       转到状态 72
+    return_token     转到状态 73
+    restarted_exp    转到状态 74
+    restarted_token  转到状态 75
+    restart_exp      转到状态 76
+    restart_token    转到状态 77
+    continued_exp    转到状态 78
+    continued_token  转到状态 79
+    continue_exp     转到状态 80
+    continue_token   转到状态 81
+    break_exp        转到状态 82
+    break_token      转到状态 83
+    broken_exp       转到状态 84
+    broken_token     转到状态 85
+    if_block         转到状态 86
+    if_exp           转到状态 87
+    block_block      转到状态 88
+    block_exp        转到状态 89
+    for_block        转到状态 90
+    for_exp          转到状态 91
+    include_exp      转到状态 92
+    import_exp       转到状态 93
+    raise_exp        转到状态 94
+    try_block        转到状态 95
+    try_exp          转到状态 96
+    try_token        转到状态 97
+    do_while_block   转到状态 98
+    while_block      转到状态 99
+    while_exp        转到状态 100
+    class_block      转到状态 101
+    class_exp        转到状态 102
+    def_block        转到状态 103
+    def_exp          转到状态 104
+    block            转到状态 236
+
+
+状态 135
+
+  169 do_while_block: DO block . while_exp
+  170               | DO block . stop_token while_exp
+
+    WHILE  偏移，并进入状态 8
+    STOPN  偏移，并进入状态 116
+    STOPF  偏移，并进入状态 117
+
+    while_exp   转到状态 237
+    stop_token  转到状态 238
+
+
+状态 136
+
+  165 raise_exp: ASSERT top_exp . top_exp
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 239
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 137
+
+    0 $accept: command_block $end .
+
+    $default  接受
+
+
+状态 138
+
+    3 command_list: command_list command .
+
+    $default  使用规则 3 以归约 (command_list)
+
+
+状态 139
+
+    4 command: top_exp stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 4 以归约 (command)
+
+
+状态 140
+
+   30 eq_number: eq_number EQ . call_number
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    call_number     转到状态 240
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 141
+
+   47 call_number: call_number LB . RB
+   48            | call_number LB . arguments RB
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    MUL         偏移，并进入状态 241
+    RB          偏移，并进入状态 242
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 243
+    eq_number       转到状态 43
+    arguments       转到状态 244
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 245
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 142
+
+   53 chose_exp: chose_exp IF . chose_exp ELSE chose_exp
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    chose_exp       转到状态 246
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 143
+
+   55 bool_or: bool_or OR . bool_and
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    bool_and        转到状态 247
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 144
+
+   57 bool_and: bool_and AND . bool_not
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    bool_not        转到状态 248
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 145
+
+   63 third_number: third_number LESS . bit_or_not
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    BITNOT      偏移，并进入状态 36
+
+    bit_or_not      转到状态 249
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 146
+
+   62 third_number: third_number MORE . bit_or_not
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    BITNOT      偏移，并进入状态 36
+
+    bit_or_not      转到状态 250
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 147
+
+   61 third_number: third_number EQUAL . bit_or_not
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    BITNOT      偏移，并进入状态 36
+
+    bit_or_not      转到状态 251
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 148
+
+   64 third_number: third_number MOREEQ . bit_or_not
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    BITNOT      偏移，并进入状态 36
+
+    bit_or_not      转到状态 252
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 149
+
+   65 third_number: third_number LESSEQ . bit_or_not
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    BITNOT      偏移，并进入状态 36
+
+    bit_or_not      转到状态 253
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 150
+
+   66 third_number: third_number NOTEQ . bit_or_not
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    BITNOT      偏移，并进入状态 36
+
+    bit_or_not      转到状态 254
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 151
+
+   68 bit_or_not: bit_or_not BITNOTOR . bit_or
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    BITNOT      偏移，并进入状态 36
+
+    bit_or          转到状态 255
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 152
+
+   70 bit_or: bit_or BITOR . bit_and
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    BITNOT      偏移，并进入状态 36
+
+    bit_and         转到状态 256
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 153
+
+   72 bit_and: bit_and BITAND . bit_move
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    BITNOT      偏移，并进入状态 36
+
+    bit_move        转到状态 257
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 154
+
+   74 bit_move: bit_move BITRIGHT . second_number
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    BITNOT      偏移，并进入状态 36
+
+    second_number   转到状态 258
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 155
+
+   75 bit_move: bit_move BITLEFT . second_number
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    BITNOT      偏移，并进入状态 36
+
+    second_number   转到状态 259
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 156
+
+   77 second_number: second_number ADD . first_number
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    BITNOT      偏移，并进入状态 36
+
+    first_number    转到状态 260
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 157
+
+   78 second_number: second_number SUB . first_number
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    BITNOT      偏移，并进入状态 36
+
+    first_number    转到状态 261
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 158
+
+   81 first_number: first_number DIV . negative
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    BITNOT      偏移，并进入状态 36
+
+    negative        转到状态 262
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 159
+
+   80 first_number: first_number MUL . negative
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    BITNOT      偏移，并进入状态 36
+
+    negative        转到状态 263
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 160
+
+   82 first_number: first_number MOD . negative
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    BITNOT      偏移，并进入状态 36
+
+    negative        转到状态 264
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 161
+
+   83 first_number: first_number INTDIV . negative
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    BITNOT      偏移，并进入状态 36
+
+    negative        转到状态 265
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 162
+
+   89 zero_number: zero_number POW . attribute
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    attribute       转到状态 266
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 163
+
+   90 zero_number: zero_number LOG . attribute
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    attribute       转到状态 267
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 164
+
+   91 zero_number: zero_number SQRT . attribute
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    attribute       转到状态 268
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 165
+
+   93 attribute: attribute POINT . call_down
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    call_down       转到状态 269
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 166
+
+   95 call_down: call_slice LI . top_exp RI
+   97 call_slice: call_slice LI . slice_arguments RI
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp                转到状态 270
+    eq_number              转到状态 43
+    slice_arguments        转到状态 271
+    slice_arguments_token  转到状态 272
+    call_number            转到状态 44
+    lambda_exp             转到状态 45
+    chose_exp              转到状态 46
+    bool_or                转到状态 47
+    bool_and               转到状态 48
+    bool_not               转到状态 49
+    third_number           转到状态 50
+    bit_or_not             转到状态 51
+    bit_or                 转到状态 52
+    bit_and                转到状态 53
+    bit_move               转到状态 54
+    second_number          转到状态 55
+    first_number           转到状态 56
+    negative               转到状态 57
+    bit_not                转到状态 58
+    zero_number            转到状态 59
+    attribute              转到状态 60
+    call_down              转到状态 61
+    call_slice             转到状态 62
+    iter_value             转到状态 63
+    element                转到状态 64
+    base_value             转到状态 65
+    base_var_              转到状态 66
+    base_var_token         转到状态 67
+    base_string            转到状态 68
+
+
+状态 167
+
+  118 base_string: base_string STRING .
+
+    $default  使用规则 118 以归约 (base_string)
+
+
+状态 168
+
+   18 command: nonlocal_token stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 18 以归约 (command)
+
+
+状态 169
+
+   16 command: global_token stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 16 以归约 (command)
+
+
+状态 170
+
+   15 command: default_token stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 15 以归约 (command)
+
+
+状态 171
+
+   21 command: return_exp stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 21 以归约 (command)
+
+
+状态 172
+
+  123 return_exp: return_token top_exp .
+  124           | return_token top_exp . element
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LI          偏移，并进入状态 111
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    $default  使用规则 123 以归约 (return_exp)
+
+    element         转到状态 273
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 173
+
+   12 command: restarted_exp stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 12 以归约 (command)
+
+
+状态 174
+
+  127 restarted_exp: restarted_token element .
+
+    $default  使用规则 127 以归约 (restarted_exp)
+
+
+状态 175
+
+   11 command: restart_exp stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 11 以归约 (command)
+
+
+状态 176
+
+  130 restart_exp: restart_token element .
+
+    $default  使用规则 130 以归约 (restart_exp)
+
+
+状态 177
+
+   10 command: continued_exp stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 10 以归约 (command)
+
+
+状态 178
+
+  133 continued_exp: continued_token element .
+
+    $default  使用规则 133 以归约 (continued_exp)
+
+
+状态 179
+
+    9 command: continue_exp stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 9 以归约 (command)
+
+
+状态 180
+
+  136 continue_exp: continue_token element .
+
+    $default  使用规则 136 以归约 (continue_exp)
+
+
+状态 181
+
+    7 command: break_exp stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 7 以归约 (command)
+
+
+状态 182
+
+  139 break_exp: break_token element .
+
+    $default  使用规则 139 以归约 (break_exp)
+
+
+状态 183
+
+    8 command: broken_exp stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 8 以归约 (command)
+
+
+状态 184
+
+  142 broken_exp: broken_token element .
+
+    $default  使用规则 142 以归约 (broken_exp)
+
+
+状态 185
+
+  147 elif_exp: ELSE .
+
+    $default  使用规则 147 以归约 (elif_exp)
+
+
+状态 186
+
+  146 elif_exp: ELIF . LB top_exp RB
+
+    LB  偏移，并进入状态 274
+
+
+状态 187
+
+  145 if_block: if_block elif_exp . block
+
+    LP  偏移，并进入状态 134
+
+    block  转到状态 275
+
+
+状态 188
+
+    6 command: if_block stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 6 以归约 (command)
+
+
+状态 189
+
+  144 if_block: if_exp block .
+
+    $default  使用规则 144 以归约 (if_block)
+
+
+状态 190
+
+   19 command: block_block stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 19 以归约 (command)
+
+
+状态 191
+
+  149 block_block: block_exp block .
+
+    $default  使用规则 149 以归约 (block_block)
+
+
+状态 192
+
+   17 command: for_block stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 17 以归约 (command)
+
+
+状态 193
+
+  151 for_block: for_exp block .
+
+    $default  使用规则 151 以归约 (for_block)
+
+
+状态 194
+
+   26 command: include_exp stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 26 以归约 (command)
+
+
+状态 195
+
+   25 command: import_exp stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 25 以归约 (command)
+
+
+状态 196
+
+   24 command: raise_exp stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 24 以归约 (command)
+
+
+状态 197
+
+   23 command: try_block stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 23 以归约 (command)
+
+
+状态 198
+
+  166 try_block: try_exp block .
+
+    $default  使用规则 166 以归约 (try_block)
+
+
+状态 199
+
+  167 try_exp: try_token block . EXCEPT AS element
+
+    EXCEPT  偏移，并进入状态 276
+
+
+状态 200
+
+   27 command: do_while_block stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 27 以归约 (command)
+
+
+状态 201
+
+    5 command: while_block stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 5 以归约 (command)
+
+
+状态 202
+
+  171 while_block: while_exp block .
+
+    $default  使用规则 171 以归约 (while_block)
+
+
+状态 203
+
+   22 command: class_block stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 22 以归约 (command)
+
+
+状态 204
+
+  173 class_block: class_exp block .
+
+    $default  使用规则 173 以归约 (class_block)
+
+
+状态 205
+
+   20 command: def_block stop_token .
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    $default  使用规则 20 以归约 (command)
+
+
+状态 206
+
+  176 def_block: def_exp block .
+
+    $default  使用规则 176 以归约 (def_block)
+
+
+状态 207
+
+  107 element: LB top_exp . RB
+
+    RB  偏移，并进入状态 211
+
+
+状态 208
+
+   32 formal_parameter: MUL top_exp .
+
+    $default  使用规则 32 以归约 (formal_parameter)
+
+
+状态 209
+
+   50 lambda_exp: LB RB LAMBDA . chose_exp
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    chose_exp       转到状态 277
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 210
+
+   33 formal_parameter: top_exp EQ . top_exp
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 278
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 211
+
+  107 element: LB top_exp RB .
+
+    $default  使用规则 107 以归约 (element)
+
+
+状态 212
+
+   51 lambda_exp: LB formal_parameter RB . LAMBDA chose_exp
+
+    LAMBDA  偏移，并进入状态 279
+
+
+状态 213
+
+   34 formal_parameter: formal_parameter COMMA . top_exp
+   35                 | formal_parameter COMMA . MUL top_exp
+   36                 | formal_parameter COMMA . top_exp EQ top_exp
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    MUL         偏移，并进入状态 280
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 281
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 214
+
+  115 base_var_: LI top_exp . RI base_var_token
+
+    RI  偏移，并进入状态 222
+
+
+状态 215
+
+  100 iter_value: LP dict_arguments RP .
+
+    $default  使用规则 100 以归约 (iter_value)
+
+
+状态 216
+
+  104 dict_arguments: dict_arguments COMMA . element EQ element
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LI          偏移，并进入状态 111
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    element         转到状态 282
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 217
+
+  103 dict_arguments: element EQ . element
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LI          偏移，并进入状态 111
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    element         转到状态 283
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 218
+
+  172 while_exp: WHILE LB top_exp . RB
+
+    RB  偏移，并进入状态 284
+
+
+状态 219
+
+  148 if_exp: IF LB top_exp . RB
+
+    RB  偏移，并进入状态 285
+
+
+状态 220
+
+  185 stop_token: stop_token STOPN .
+
+    $default  使用规则 185 以归约 (stop_token)
+
+
+状态 221
+
+  184 stop_token: stop_token STOPF .
+
+    $default  使用规则 184 以归约 (stop_token)
+
+
+状态 222
+
+  115 base_var_: LI top_exp RI . base_var_token
+
+    VAR  偏移，并进入状态 4
+
+    base_var_token  转到状态 286
+
+
+状态 223
+
+   99 iter_value: LI list_arguments RI .
+
+    $default  使用规则 99 以归约 (iter_value)
+
+
+状态 224
+
+  102 list_arguments: list_arguments COMMA . top_exp
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 287
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 225
+
+  121 default_token: DEFAULT base_var_token element .
+
+    $default  使用规则 121 以归约 (default_token)
+
+
+状态 226
+
+  152 for_exp: FOR LB COMMA . COMMA RB
+  154        | FOR LB COMMA . top_exp COMMA RB
+  155        | FOR LB COMMA . COMMA top_exp RB
+  158        | FOR LB COMMA . top_exp COMMA top_exp RB
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    COMMA       偏移，并进入状态 288
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 289
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 227
+
+  153 for_exp: FOR LB top_exp . COMMA COMMA RB
+  156        | FOR LB top_exp . COMMA COMMA top_exp RB
+  157        | FOR LB top_exp . COMMA top_exp COMMA RB
+  159        | FOR LB top_exp . COMMA top_exp COMMA top_exp RB
+
+    COMMA  偏移，并进入状态 290
+
+
+状态 228
+
+   98 iter_value: element .
+  160 for_exp: FOR LB element . IN top_exp RB
+
+    IN  偏移，并进入状态 291
+
+    $default  使用规则 98 以归约 (iter_value)
+
+
+状态 229
+
+  177 def_exp: DEF element LB . RB
+  178        | DEF element LB . formal_parameter RB
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    MUL         偏移，并进入状态 107
+    RB          偏移，并进入状态 292
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp           转到状态 293
+    eq_number         转到状态 43
+    formal_parameter  转到状态 294
+    call_number       转到状态 44
+    lambda_exp        转到状态 45
+    chose_exp         转到状态 46
+    bool_or           转到状态 47
+    bool_and          转到状态 48
+    bool_not          转到状态 49
+    third_number      转到状态 50
+    bit_or_not        转到状态 51
+    bit_or            转到状态 52
+    bit_and           转到状态 53
+    bit_move          转到状态 54
+    second_number     转到状态 55
+    first_number      转到状态 56
+    negative          转到状态 57
+    bit_not           转到状态 58
+    zero_number       转到状态 59
+    attribute         转到状态 60
+    call_down         转到状态 61
+    call_slice        转到状态 62
+    iter_value        转到状态 63
+    element           转到状态 64
+    base_value        转到状态 65
+    base_var_         转到状态 66
+    base_var_token    转到状态 67
+    base_string       转到状态 68
+
+
+状态 230
+
+  174 class_exp: CLASS element LB . RB
+  175          | CLASS element LB . arguments RB
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    MUL         偏移，并进入状态 241
+    RB          偏移，并进入状态 295
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 243
+    eq_number       转到状态 43
+    arguments       转到状态 296
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 245
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 231
+
+  163 raise_exp: RAISE top_exp top_exp .
+
+    $default  使用规则 163 以归约 (raise_exp)
+
+
+状态 232
+
+  162 import_exp: IMPORT top_exp AS . element
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LI          偏移，并进入状态 111
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    element         转到状态 297
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 233
+
+  100 iter_value: LP . dict_arguments RP
+  179 block: LP . command_list RP
+  180      | LP . block RP
+  181      | LP . PASS RP
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 233
+    WHILE       偏移，并进入状态 8
+    BREAK       偏移，并进入状态 9
+    IF          偏移，并进入状态 10
+    BROKEN      偏移，并进入状态 11
+    CONTINUE    偏移，并进入状态 12
+    CONTINUED   偏移，并进入状态 13
+    RESTART     偏移，并进入状态 14
+    RESTARTED   偏移，并进入状态 15
+    REGO        偏移，并进入状态 16
+    REWENT      偏移，并进入状态 17
+    LI          偏移，并进入状态 18
+    DEFAULT     偏移，并进入状态 19
+    FOR         偏移，并进入状态 20
+    GLOBAL      偏移，并进入状态 21
+    NONLOCAL    偏移，并进入状态 22
+    BLOCK       偏移，并进入状态 23
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    DEF         偏移，并进入状态 27
+    RETURN      偏移，并进入状态 28
+    CLASS       偏移，并进入状态 29
+    TRY         偏移，并进入状态 30
+    RAISE       偏移，并进入状态 31
+    THROW       偏移，并进入状态 32
+    IMPORT      偏移，并进入状态 33
+    INCLUDE     偏移，并进入状态 34
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+    PASS        偏移，并进入状态 234
+    DO          偏移，并进入状态 37
+    ASSERT      偏移，并进入状态 38
+
+    command_list     转到状态 235
+    command          转到状态 41
+    top_exp          转到状态 42
+    eq_number        转到状态 43
+    call_number      转到状态 44
+    lambda_exp       转到状态 45
+    chose_exp        转到状态 46
+    bool_or          转到状态 47
+    bool_and         转到状态 48
+    bool_not         转到状态 49
+    third_number     转到状态 50
+    bit_or_not       转到状态 51
+    bit_or           转到状态 52
+    bit_and          转到状态 53
+    bit_move         转到状态 54
+    second_number    转到状态 55
+    first_number     转到状态 56
+    negative         转到状态 57
+    bit_not          转到状态 58
+    zero_number      转到状态 59
+    attribute        转到状态 60
+    call_down        转到状态 61
+    call_slice       转到状态 62
+    iter_value       转到状态 63
+    dict_arguments   转到状态 112
+    element          转到状态 298
+    base_value       转到状态 65
+    base_var_        转到状态 66
+    base_var_token   转到状态 67
+    base_string      转到状态 68
+    nonlocal_token   转到状态 69
+    global_token     转到状态 70
+    default_token    转到状态 71
+    return_exp       转到状态 72
+    return_token     转到状态 73
+    restarted_exp    转到状态 74
+    restarted_token  转到状态 75
+    restart_exp      转到状态 76
+    restart_token    转到状态 77
+    continued_exp    转到状态 78
+    continued_token  转到状态 79
+    continue_exp     转到状态 80
+    continue_token   转到状态 81
+    break_exp        转到状态 82
+    break_token      转到状态 83
+    broken_exp       转到状态 84
+    broken_token     转到状态 85
+    if_block         转到状态 86
+    if_exp           转到状态 87
+    block_block      转到状态 88
+    block_exp        转到状态 89
+    for_block        转到状态 90
+    for_exp          转到状态 91
+    include_exp      转到状态 92
+    import_exp       转到状态 93
+    raise_exp        转到状态 94
+    try_block        转到状态 95
+    try_exp          转到状态 96
+    try_token        转到状态 97
+    do_while_block   转到状态 98
+    while_block      转到状态 99
+    while_exp        转到状态 100
+    class_block      转到状态 101
+    class_exp        转到状态 102
+    def_block        转到状态 103
+    def_exp          转到状态 104
+    block            转到状态 236
+
+
+状态 234
+
+  181 block: LP PASS . RP
+
+    RP  偏移，并进入状态 299
+
+
+状态 235
+
+    3 command_list: command_list . command
+  179 block: LP command_list . RP
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    RP          偏移，并进入状态 300
+    LP          偏移，并进入状态 7
+    WHILE       偏移，并进入状态 8
+    BREAK       偏移，并进入状态 9
+    IF          偏移，并进入状态 10
+    BROKEN      偏移，并进入状态 11
+    CONTINUE    偏移，并进入状态 12
+    CONTINUED   偏移，并进入状态 13
+    RESTART     偏移，并进入状态 14
+    RESTARTED   偏移，并进入状态 15
+    REGO        偏移，并进入状态 16
+    REWENT      偏移，并进入状态 17
+    LI          偏移，并进入状态 18
+    DEFAULT     偏移，并进入状态 19
+    FOR         偏移，并进入状态 20
+    GLOBAL      偏移，并进入状态 21
+    NONLOCAL    偏移，并进入状态 22
+    BLOCK       偏移，并进入状态 23
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    DEF         偏移，并进入状态 27
+    RETURN      偏移，并进入状态 28
+    CLASS       偏移，并进入状态 29
+    TRY         偏移，并进入状态 30
+    RAISE       偏移，并进入状态 31
+    THROW       偏移，并进入状态 32
+    IMPORT      偏移，并进入状态 33
+    INCLUDE     偏移，并进入状态 34
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+    DO          偏移，并进入状态 37
+    ASSERT      偏移，并进入状态 38
+
+    command          转到状态 138
+    top_exp          转到状态 42
+    eq_number        转到状态 43
+    call_number      转到状态 44
+    lambda_exp       转到状态 45
+    chose_exp        转到状态 46
+    bool_or          转到状态 47
+    bool_and         转到状态 48
+    bool_not         转到状态 49
+    third_number     转到状态 50
+    bit_or_not       转到状态 51
+    bit_or           转到状态 52
+    bit_and          转到状态 53
+    bit_move         转到状态 54
+    second_number    转到状态 55
+    first_number     转到状态 56
+    negative         转到状态 57
+    bit_not          转到状态 58
+    zero_number      转到状态 59
+    attribute        转到状态 60
+    call_down        转到状态 61
+    call_slice       转到状态 62
+    iter_value       转到状态 63
+    element          转到状态 64
+    base_value       转到状态 65
+    base_var_        转到状态 66
+    base_var_token   转到状态 67
+    base_string      转到状态 68
+    nonlocal_token   转到状态 69
+    global_token     转到状态 70
+    default_token    转到状态 71
+    return_exp       转到状态 72
+    return_token     转到状态 73
+    restarted_exp    转到状态 74
+    restarted_token  转到状态 75
+    restart_exp      转到状态 76
+    restart_token    转到状态 77
+    continued_exp    转到状态 78
+    continued_token  转到状态 79
+    continue_exp     转到状态 80
+    continue_token   转到状态 81
+    break_exp        转到状态 82
+    break_token      转到状态 83
+    broken_exp       转到状态 84
+    broken_token     转到状态 85
+    if_block         转到状态 86
+    if_exp           转到状态 87
+    block_block      转到状态 88
+    block_exp        转到状态 89
+    for_block        转到状态 90
+    for_exp          转到状态 91
+    include_exp      转到状态 92
+    import_exp       转到状态 93
+    raise_exp        转到状态 94
+    try_block        转到状态 95
+    try_exp          转到状态 96
+    try_token        转到状态 97
+    do_while_block   转到状态 98
+    while_block      转到状态 99
+    while_exp        转到状态 100
+    class_block      转到状态 101
+    class_exp        转到状态 102
+    def_block        转到状态 103
+    def_exp          转到状态 104
+
+
+状态 236
+
+  180 block: LP block . RP
+
+    RP  偏移，并进入状态 301
+
+
+状态 237
+
+  169 do_while_block: DO block while_exp .
+
+    $default  使用规则 169 以归约 (do_while_block)
+
+
+状态 238
+
+  170 do_while_block: DO block stop_token . while_exp
+  184 stop_token: stop_token . STOPF
+  185           | stop_token . STOPN
+
+    WHILE  偏移，并进入状态 8
+    STOPN  偏移，并进入状态 220
+    STOPF  偏移，并进入状态 221
+
+    while_exp  转到状态 302
+
+
+状态 239
+
+  165 raise_exp: ASSERT top_exp top_exp .
+
+    $default  使用规则 165 以归约 (raise_exp)
+
+
+状态 240
+
+   30 eq_number: eq_number EQ call_number .
+   47 call_number: call_number . LB RB
+   48            | call_number . LB arguments RB
+
+    LB  偏移，并进入状态 141
+
+    LB        [使用规则 30 以归约 (eq_number)]
+    $default  使用规则 30 以归约 (eq_number)
+
+
+状态 241
+
+   41 arguments: MUL . top_exp
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 303
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 242
+
+   47 call_number: call_number LB RB .
+
+    $default  使用规则 47 以归约 (call_number)
+
+
+状态 243
+
+   37 arguments: top_exp .
+
+    $default  使用规则 37 以归约 (arguments)
+
+
+状态 244
+
+   38 arguments: arguments . COMMA top_exp
+   40          | arguments . COMMA base_var_ EQ top_exp
+   48 call_number: call_number LB arguments . RB
+
+    RB     偏移，并进入状态 304
+    COMMA  偏移，并进入状态 305
+
+
+状态 245
+
+   39 arguments: base_var_ . EQ top_exp
+  106 element: base_var_ .
+
+    EQ  偏移，并进入状态 306
+
+    EQ        [使用规则 106 以归约 (element)]
+    $default  使用规则 106 以归约 (element)
+
+
+状态 246
+
+   53 chose_exp: chose_exp . IF chose_exp ELSE chose_exp
+   53          | chose_exp IF chose_exp . ELSE chose_exp
+
+    IF    偏移，并进入状态 142
+    ELSE  偏移，并进入状态 307
+
+
+状态 247
+
+   55 bool_or: bool_or OR bool_and .
+   57 bool_and: bool_and . AND bool_not
+
+    AND  偏移，并进入状态 144
+
+    $default  使用规则 55 以归约 (bool_or)
+
+
+状态 248
+
+   57 bool_and: bool_and AND bool_not .
+
+    $default  使用规则 57 以归约 (bool_and)
+
+
+状态 249
+
+   63 third_number: third_number LESS bit_or_not .
+   68 bit_or_not: bit_or_not . BITNOTOR bit_or
+
+    BITNOTOR  偏移，并进入状态 151
+
+    $default  使用规则 63 以归约 (third_number)
+
+
+状态 250
+
+   62 third_number: third_number MORE bit_or_not .
+   68 bit_or_not: bit_or_not . BITNOTOR bit_or
+
+    BITNOTOR  偏移，并进入状态 151
+
+    $default  使用规则 62 以归约 (third_number)
+
+
+状态 251
+
+   61 third_number: third_number EQUAL bit_or_not .
+   68 bit_or_not: bit_or_not . BITNOTOR bit_or
+
+    BITNOTOR  偏移，并进入状态 151
+
+    $default  使用规则 61 以归约 (third_number)
+
+
+状态 252
+
+   64 third_number: third_number MOREEQ bit_or_not .
+   68 bit_or_not: bit_or_not . BITNOTOR bit_or
+
+    BITNOTOR  偏移，并进入状态 151
+
+    $default  使用规则 64 以归约 (third_number)
+
+
+状态 253
+
+   65 third_number: third_number LESSEQ bit_or_not .
+   68 bit_or_not: bit_or_not . BITNOTOR bit_or
+
+    BITNOTOR  偏移，并进入状态 151
+
+    $default  使用规则 65 以归约 (third_number)
+
+
+状态 254
+
+   66 third_number: third_number NOTEQ bit_or_not .
+   68 bit_or_not: bit_or_not . BITNOTOR bit_or
+
+    BITNOTOR  偏移，并进入状态 151
+
+    $default  使用规则 66 以归约 (third_number)
+
+
+状态 255
+
+   68 bit_or_not: bit_or_not BITNOTOR bit_or .
+   70 bit_or: bit_or . BITOR bit_and
+
+    BITOR  偏移，并进入状态 152
+
+    $default  使用规则 68 以归约 (bit_or_not)
+
+
+状态 256
+
+   70 bit_or: bit_or BITOR bit_and .
+   72 bit_and: bit_and . BITAND bit_move
+
+    BITAND  偏移，并进入状态 153
+
+    $default  使用规则 70 以归约 (bit_or)
+
+
+状态 257
+
+   72 bit_and: bit_and BITAND bit_move .
+   74 bit_move: bit_move . BITRIGHT second_number
+   75         | bit_move . BITLEFT second_number
+
+    BITRIGHT  偏移，并进入状态 154
+    BITLEFT   偏移，并进入状态 155
+
+    $default  使用规则 72 以归约 (bit_and)
+
+
+状态 258
+
+   74 bit_move: bit_move BITRIGHT second_number .
+   77 second_number: second_number . ADD first_number
+   78              | second_number . SUB first_number
+
+    ADD  偏移，并进入状态 156
+    SUB  偏移，并进入状态 157
+
+    SUB       [使用规则 74 以归约 (bit_move)]
+    $default  使用规则 74 以归约 (bit_move)
+
+
+状态 259
+
+   75 bit_move: bit_move BITLEFT second_number .
+   77 second_number: second_number . ADD first_number
+   78              | second_number . SUB first_number
+
+    ADD  偏移，并进入状态 156
+    SUB  偏移，并进入状态 157
+
+    SUB       [使用规则 75 以归约 (bit_move)]
+    $default  使用规则 75 以归约 (bit_move)
+
+
+状态 260
+
+   77 second_number: second_number ADD first_number .
+   80 first_number: first_number . MUL negative
+   81             | first_number . DIV negative
+   82             | first_number . MOD negative
+   83             | first_number . INTDIV negative
+
+    DIV     偏移，并进入状态 158
+    MUL     偏移，并进入状态 159
+    MOD     偏移，并进入状态 160
+    INTDIV  偏移，并进入状态 161
+
+    $default  使用规则 77 以归约 (second_number)
+
+
+状态 261
+
+   78 second_number: second_number SUB first_number .
+   80 first_number: first_number . MUL negative
+   81             | first_number . DIV negative
+   82             | first_number . MOD negative
+   83             | first_number . INTDIV negative
+
+    DIV     偏移，并进入状态 158
+    MUL     偏移，并进入状态 159
+    MOD     偏移，并进入状态 160
+    INTDIV  偏移，并进入状态 161
+
+    $default  使用规则 78 以归约 (second_number)
+
+
+状态 262
+
+   81 first_number: first_number DIV negative .
+
+    $default  使用规则 81 以归约 (first_number)
+
+
+状态 263
+
+   80 first_number: first_number MUL negative .
+
+    $default  使用规则 80 以归约 (first_number)
+
+
+状态 264
+
+   82 first_number: first_number MOD negative .
+
+    $default  使用规则 82 以归约 (first_number)
+
+
+状态 265
+
+   83 first_number: first_number INTDIV negative .
+
+    $default  使用规则 83 以归约 (first_number)
+
+
+状态 266
+
+   89 zero_number: zero_number POW attribute .
+   93 attribute: attribute . POINT call_down
+
+    POINT  偏移，并进入状态 165
+
+    $default  使用规则 89 以归约 (zero_number)
+
+
+状态 267
+
+   90 zero_number: zero_number LOG attribute .
+   93 attribute: attribute . POINT call_down
+
+    POINT  偏移，并进入状态 165
+
+    $default  使用规则 90 以归约 (zero_number)
+
+
+状态 268
+
+   91 zero_number: zero_number SQRT attribute .
+   93 attribute: attribute . POINT call_down
+
+    POINT  偏移，并进入状态 165
+
+    $default  使用规则 91 以归约 (zero_number)
+
+
+状态 269
+
+   93 attribute: attribute POINT call_down .
+
+    $default  使用规则 93 以归约 (attribute)
+
+
+状态 270
+
+   45 slice_arguments_token: top_exp . COLON
+   95 call_down: call_slice LI top_exp . RI
+
+    RI     偏移，并进入状态 308
+    COLON  偏移，并进入状态 309
+
+
+状态 271
+
+   43 slice_arguments: slice_arguments . slice_arguments_token
+   44                | slice_arguments . top_exp
+   97 call_slice: call_slice LI slice_arguments . RI
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    RI          偏移，并进入状态 310
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp                转到状态 311
+    eq_number              转到状态 43
+    slice_arguments_token  转到状态 312
+    call_number            转到状态 44
+    lambda_exp             转到状态 45
+    chose_exp              转到状态 46
+    bool_or                转到状态 47
+    bool_and               转到状态 48
+    bool_not               转到状态 49
+    third_number           转到状态 50
+    bit_or_not             转到状态 51
+    bit_or                 转到状态 52
+    bit_and                转到状态 53
+    bit_move               转到状态 54
+    second_number          转到状态 55
+    first_number           转到状态 56
+    negative               转到状态 57
+    bit_not                转到状态 58
+    zero_number            转到状态 59
+    attribute              转到状态 60
+    call_down              转到状态 61
+    call_slice             转到状态 62
+    iter_value             转到状态 63
+    element                转到状态 64
+    base_value             转到状态 65
+    base_var_              转到状态 66
+    base_var_token         转到状态 67
+    base_string            转到状态 68
+
+
+状态 272
+
+   42 slice_arguments: slice_arguments_token .
+
+    $default  使用规则 42 以归约 (slice_arguments)
+
+
+状态 273
+
+  124 return_exp: return_token top_exp element .
+
+    $default  使用规则 124 以归约 (return_exp)
+
+
+状态 274
+
+  146 elif_exp: ELIF LB . top_exp RB
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 313
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 275
+
+  145 if_block: if_block elif_exp block .
+
+    $default  使用规则 145 以归约 (if_block)
+
+
+状态 276
+
+  167 try_exp: try_token block EXCEPT . AS element
+
+    AS  偏移，并进入状态 314
+
+
+状态 277
+
+   50 lambda_exp: LB RB LAMBDA chose_exp .
+   53 chose_exp: chose_exp . IF chose_exp ELSE chose_exp
+
+    IF  偏移，并进入状态 142
+
+    $default  使用规则 50 以归约 (lambda_exp)
+
+
+状态 278
+
+   33 formal_parameter: top_exp EQ top_exp .
+
+    $default  使用规则 33 以归约 (formal_parameter)
+
+
+状态 279
+
+   51 lambda_exp: LB formal_parameter RB LAMBDA . chose_exp
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    chose_exp       转到状态 315
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 280
+
+   35 formal_parameter: formal_parameter COMMA MUL . top_exp
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 316
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 281
+
+   34 formal_parameter: formal_parameter COMMA top_exp .
+   36                 | formal_parameter COMMA top_exp . EQ top_exp
+
+    EQ  偏移，并进入状态 317
+
+    $default  使用规则 34 以归约 (formal_parameter)
+
+
+状态 282
+
+  104 dict_arguments: dict_arguments COMMA element . EQ element
+
+    EQ  偏移，并进入状态 318
+
+
+状态 283
+
+  103 dict_arguments: element EQ element .
+
+    $default  使用规则 103 以归约 (dict_arguments)
+
+
+状态 284
+
+  172 while_exp: WHILE LB top_exp RB .
+
+    $default  使用规则 172 以归约 (while_exp)
+
+
+状态 285
+
+  148 if_exp: IF LB top_exp RB .
+
+    $default  使用规则 148 以归约 (if_exp)
+
+
+状态 286
+
+  115 base_var_: LI top_exp RI base_var_token .
+
+    $default  使用规则 115 以归约 (base_var_)
+
+
+状态 287
+
+  102 list_arguments: list_arguments COMMA top_exp .
+
+    $default  使用规则 102 以归约 (list_arguments)
+
+
+状态 288
+
+  152 for_exp: FOR LB COMMA COMMA . RB
+  155        | FOR LB COMMA COMMA . top_exp RB
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    RB          偏移，并进入状态 319
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 320
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 289
+
+  154 for_exp: FOR LB COMMA top_exp . COMMA RB
+  158        | FOR LB COMMA top_exp . COMMA top_exp RB
+
+    COMMA  偏移，并进入状态 321
+
+
+状态 290
+
+  153 for_exp: FOR LB top_exp COMMA . COMMA RB
+  156        | FOR LB top_exp COMMA . COMMA top_exp RB
+  157        | FOR LB top_exp COMMA . top_exp COMMA RB
+  159        | FOR LB top_exp COMMA . top_exp COMMA top_exp RB
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    COMMA       偏移，并进入状态 322
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 323
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 291
+
+  160 for_exp: FOR LB element IN . top_exp RB
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 324
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 292
+
+  177 def_exp: DEF element LB RB .
+
+    $default  使用规则 177 以归约 (def_exp)
+
+
+状态 293
+
+   31 formal_parameter: top_exp .
+   33                 | top_exp . EQ top_exp
+
+    EQ  偏移，并进入状态 210
+
+    $default  使用规则 31 以归约 (formal_parameter)
+
+
+状态 294
+
+   34 formal_parameter: formal_parameter . COMMA top_exp
+   35                 | formal_parameter . COMMA MUL top_exp
+   36                 | formal_parameter . COMMA top_exp EQ top_exp
+  178 def_exp: DEF element LB formal_parameter . RB
+
+    RB     偏移，并进入状态 325
+    COMMA  偏移，并进入状态 213
+
+
+状态 295
+
+  174 class_exp: CLASS element LB RB .
+
+    $default  使用规则 174 以归约 (class_exp)
+
+
+状态 296
+
+   38 arguments: arguments . COMMA top_exp
+   40          | arguments . COMMA base_var_ EQ top_exp
+  175 class_exp: CLASS element LB arguments . RB
+
+    RB     偏移，并进入状态 326
+    COMMA  偏移，并进入状态 305
+
+
+状态 297
+
+  162 import_exp: IMPORT top_exp AS element .
+
+    $default  使用规则 162 以归约 (import_exp)
+
+
+状态 298
+
+   98 iter_value: element .
+  103 dict_arguments: element . EQ element
+
+    EQ  偏移，并进入状态 217
+
+    EQ        [使用规则 98 以归约 (iter_value)]
+    $default  使用规则 98 以归约 (iter_value)
+
+
+状态 299
+
+  181 block: LP PASS RP .
+
+    $default  使用规则 181 以归约 (block)
+
+
+状态 300
+
+  179 block: LP command_list RP .
+
+    $default  使用规则 179 以归约 (block)
+
+
+状态 301
+
+  180 block: LP block RP .
+
+    $default  使用规则 180 以归约 (block)
+
+
+状态 302
+
+  170 do_while_block: DO block stop_token while_exp .
+
+    $default  使用规则 170 以归约 (do_while_block)
+
+
+状态 303
+
+   41 arguments: MUL top_exp .
+
+    $default  使用规则 41 以归约 (arguments)
+
+
+状态 304
+
+   48 call_number: call_number LB arguments RB .
+
+    $default  使用规则 48 以归约 (call_number)
+
+
+状态 305
+
+   38 arguments: arguments COMMA . top_exp
+   40          | arguments COMMA . base_var_ EQ top_exp
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 327
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 328
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 306
+
+   39 arguments: base_var_ EQ . top_exp
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 329
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 307
+
+   53 chose_exp: chose_exp IF chose_exp ELSE . chose_exp
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 105
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    chose_exp       转到状态 330
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 308
+
+   95 call_down: call_slice LI top_exp RI .
+
+    $default  使用规则 95 以归约 (call_down)
+
+
+状态 309
+
+   45 slice_arguments_token: top_exp COLON .
+
+    $default  使用规则 45 以归约 (slice_arguments_token)
+
+
+状态 310
+
+   97 call_slice: call_slice LI slice_arguments RI .
+
+    $default  使用规则 97 以归约 (call_slice)
+
+
+状态 311
+
+   44 slice_arguments: slice_arguments top_exp .
+   45 slice_arguments_token: top_exp . COLON
+
+    COLON  偏移，并进入状态 309
+
+    $default  使用规则 44 以归约 (slice_arguments)
+
+
+状态 312
+
+   43 slice_arguments: slice_arguments slice_arguments_token .
+
+    $default  使用规则 43 以归约 (slice_arguments)
+
+
+状态 313
+
+  146 elif_exp: ELIF LB top_exp . RB
+
+    RB  偏移，并进入状态 331
+
+
+状态 314
+
+  167 try_exp: try_token block EXCEPT AS . element
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LI          偏移，并进入状态 111
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    element         转到状态 332
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 315
+
+   51 lambda_exp: LB formal_parameter RB LAMBDA chose_exp .
+   53 chose_exp: chose_exp . IF chose_exp ELSE chose_exp
+
+    IF  偏移，并进入状态 142
+
+    $default  使用规则 51 以归约 (lambda_exp)
+
+
+状态 316
+
+   35 formal_parameter: formal_parameter COMMA MUL top_exp .
+
+    $default  使用规则 35 以归约 (formal_parameter)
+
+
+状态 317
+
+   36 formal_parameter: formal_parameter COMMA top_exp EQ . top_exp
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 333
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 318
+
+  104 dict_arguments: dict_arguments COMMA element EQ . element
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    LB          偏移，并进入状态 105
+    LI          偏移，并进入状态 111
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+
+    element         转到状态 334
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 319
+
+  152 for_exp: FOR LB COMMA COMMA RB .
+
+    $default  使用规则 152 以归约 (for_exp)
+
+
+状态 320
+
+  155 for_exp: FOR LB COMMA COMMA top_exp . RB
+
+    RB  偏移，并进入状态 335
+
+
+状态 321
+
+  154 for_exp: FOR LB COMMA top_exp COMMA . RB
+  158        | FOR LB COMMA top_exp COMMA . top_exp RB
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    RB          偏移，并进入状态 336
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 337
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 322
+
+  153 for_exp: FOR LB top_exp COMMA COMMA . RB
+  156        | FOR LB top_exp COMMA COMMA . top_exp RB
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    RB          偏移，并进入状态 338
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 339
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 323
+
+  157 for_exp: FOR LB top_exp COMMA top_exp . COMMA RB
+  159        | FOR LB top_exp COMMA top_exp . COMMA top_exp RB
+
+    COMMA  偏移，并进入状态 340
+
+
+状态 324
+
+  160 for_exp: FOR LB element IN top_exp . RB
+
+    RB  偏移，并进入状态 341
+
+
+状态 325
+
+  178 def_exp: DEF element LB formal_parameter RB .
+
+    $default  使用规则 178 以归约 (def_exp)
+
+
+状态 326
+
+  175 class_exp: CLASS element LB arguments RB .
+
+    $default  使用规则 175 以归约 (class_exp)
+
+
+状态 327
+
+   38 arguments: arguments COMMA top_exp .
+
+    $default  使用规则 38 以归约 (arguments)
+
+
+状态 328
+
+   40 arguments: arguments COMMA base_var_ . EQ top_exp
+  106 element: base_var_ .
+
+    EQ  偏移，并进入状态 342
+
+    EQ        [使用规则 106 以归约 (element)]
+    $default  使用规则 106 以归约 (element)
+
+
+状态 329
+
+   39 arguments: base_var_ EQ top_exp .
+
+    $default  使用规则 39 以归约 (arguments)
+
+
+状态 330
+
+   53 chose_exp: chose_exp . IF chose_exp ELSE chose_exp
+   53          | chose_exp IF chose_exp ELSE chose_exp .
+
+    IF  偏移，并进入状态 142
+
+    IF        [使用规则 53 以归约 (chose_exp)]
+    $default  使用规则 53 以归约 (chose_exp)
+
+
+状态 331
+
+  146 elif_exp: ELIF LB top_exp RB .
+
+    $default  使用规则 146 以归约 (elif_exp)
+
+
+状态 332
+
+  167 try_exp: try_token block EXCEPT AS element .
+
+    $default  使用规则 167 以归约 (try_exp)
+
+
+状态 333
+
+   36 formal_parameter: formal_parameter COMMA top_exp EQ top_exp .
+
+    $default  使用规则 36 以归约 (formal_parameter)
+
+
+状态 334
+
+  104 dict_arguments: dict_arguments COMMA element EQ element .
+
+    $default  使用规则 104 以归约 (dict_arguments)
+
+
+状态 335
+
+  155 for_exp: FOR LB COMMA COMMA top_exp RB .
+
+    $default  使用规则 155 以归约 (for_exp)
+
+
+状态 336
+
+  154 for_exp: FOR LB COMMA top_exp COMMA RB .
+
+    $default  使用规则 154 以归约 (for_exp)
+
+
+状态 337
+
+  158 for_exp: FOR LB COMMA top_exp COMMA top_exp . RB
+
+    RB  偏移，并进入状态 343
+
+
+状态 338
+
+  153 for_exp: FOR LB top_exp COMMA COMMA RB .
+
+    $default  使用规则 153 以归约 (for_exp)
+
+
+状态 339
+
+  156 for_exp: FOR LB top_exp COMMA COMMA top_exp . RB
+
+    RB  偏移，并进入状态 344
+
+
+状态 340
+
+  157 for_exp: FOR LB top_exp COMMA top_exp COMMA . RB
+  159        | FOR LB top_exp COMMA top_exp COMMA . top_exp RB
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    RB          偏移，并进入状态 345
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 346
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 341
+
+  160 for_exp: FOR LB element IN top_exp RB .
+
+    $default  使用规则 160 以归约 (for_exp)
+
+
+状态 342
+
+   40 arguments: arguments COMMA base_var_ EQ . top_exp
+
+    NUMBER      偏移，并进入状态 1
+    INT         偏移，并进入状态 2
+    STRING      偏移，并进入状态 3
+    VAR         偏移，并进入状态 4
+    SUB         偏移，并进入状态 5
+    LB          偏移，并进入状态 6
+    LP          偏移，并进入状态 7
+    LI          偏移，并进入状态 18
+    FALSE       偏移，并进入状态 24
+    TRUE        偏移，并进入状态 25
+    NULL_token  偏移，并进入状态 26
+    NOT         偏移，并进入状态 35
+    BITNOT      偏移，并进入状态 36
+
+    top_exp         转到状态 347
+    eq_number       转到状态 43
+    call_number     转到状态 44
+    lambda_exp      转到状态 45
+    chose_exp       转到状态 46
+    bool_or         转到状态 47
+    bool_and        转到状态 48
+    bool_not        转到状态 49
+    third_number    转到状态 50
+    bit_or_not      转到状态 51
+    bit_or          转到状态 52
+    bit_and         转到状态 53
+    bit_move        转到状态 54
+    second_number   转到状态 55
+    first_number    转到状态 56
+    negative        转到状态 57
+    bit_not         转到状态 58
+    zero_number     转到状态 59
+    attribute       转到状态 60
+    call_down       转到状态 61
+    call_slice      转到状态 62
+    iter_value      转到状态 63
+    element         转到状态 64
+    base_value      转到状态 65
+    base_var_       转到状态 66
+    base_var_token  转到状态 67
+    base_string     转到状态 68
+
+
+状态 343
+
+  158 for_exp: FOR LB COMMA top_exp COMMA top_exp RB .
+
+    $default  使用规则 158 以归约 (for_exp)
+
+
+状态 344
+
+  156 for_exp: FOR LB top_exp COMMA COMMA top_exp RB .
+
+    $default  使用规则 156 以归约 (for_exp)
+
+
+状态 345
+
+  157 for_exp: FOR LB top_exp COMMA top_exp COMMA RB .
+
+    $default  使用规则 157 以归约 (for_exp)
+
+
+状态 346
+
+  159 for_exp: FOR LB top_exp COMMA top_exp COMMA top_exp . RB
+
+    RB  偏移，并进入状态 348
+
+
+状态 347
+
+   40 arguments: arguments COMMA base_var_ EQ top_exp .
+
+    $default  使用规则 40 以归约 (arguments)
+
+
+状态 348
+
+  159 for_exp: FOR LB top_exp COMMA top_exp COMMA top_exp RB .
+
+    $default  使用规则 159 以归约 (for_exp)