/* Tree transformation code.
 *
 * This file was generated from "/lhome/grubba/Pike/9.0/src/treeopt.in".
 *
 * Do NOT edit!
 */

#ifdef PIKE_DEBUG
#define DBG(X) if (l_flag>4) { fprintf(stderr, (X)); }
#else
#define DBG(X)
#endif

case '?':
  if (!CAR(n)) {
    if (!CDR(n)) {
      DBG("Match: ""'?'{777}(-{778}, -{779})""\n");
      DBG("=> ""-{780}""\n");
      goto zap_node;
    } else {
      if (CDR(n)->token == ':') {
        DBG("Match: ""'?'{781}(-{782}, ':'{783}(*, 0 = *{785}))""\n");
        DBG("=> ""0 = *{786}""\n");
        {
          ADD_NODE_REF2(CDDR(n),
            tmp1 = CDDR(n);
          );
          goto use_tmp1;
        }
      }
    }
  } else if (!CDR(n)) {
    DBG("Match: ""'?'{787}(0 = *{788}, -{789})""\n");
    DBG("=> ""0 = *{790}""\n");
    goto use_car;
  } else {
    if (CAR(n)->token == F_APPLY) {
      if (!CAAR(n)) {
      } else {
        if (CAAR(n)->token == F_CONSTANT) {
          if ((TYPEOF(CAAR(n)->u.sval) == T_FUNCTION) &&
              (SUBTYPEOF(CAAR(n)->u.sval) == FUNCTION_BUILTIN) &&
              (CAAR(n)->u.sval.u.efun->function == f_not)) {
            if (!CDR(n)) {
            } else {
              if (CDR(n)->token == ':') {
                DBG("Match: ""'?'{797}(F_APPLY{798}(F_CONSTANT{799}[TYPEOF(CAAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAAR(n)->u.sval) == FUNCTION_BUILTIN][CAAR(n)->u.sval.u.efun->function == f_not], 0 = *{800}), ':'{801}(1 = *{802}, 2 = *{803}))""\n");
                DBG("=> ""'?'{804}""\n");
                {
                  ADD_NODE_REF2(CDAR(n),
                  ADD_NODE_REF2(CDDR(n),
                  ADD_NODE_REF2(CADR(n),
                    tmp1 = mknode('?', CDAR(n), mknode(':', CDDR(n), CADR(n)));
                  )));
                  goto use_tmp1;
                }
              }
            }
          }
        }
      }
    } else if (CAR(n)->token == F_LAND) {
      if (!CAAR(n)) {
      } else {
        if (!CDAR(n)) {
        } else {
          if ((node_is_false(CDAR(n)))) {
            if (!CDR(n)) {
            } else {
              if (CDR(n)->token == ':') {
                DBG("Match: ""'?'{821}(F_LAND{822}(0 = +{823}, +{824}[node_is_false(CDAR(n))]), ':'{825}(*, 1 = *{827}))""\n");
                DBG("=> ""F_COMMA_EXPR{828}""\n");
                {
                  ADD_NODE_REF2(CAAR(n),
                  ADD_NODE_REF2(CDDR(n),
                    tmp1 = mknode(F_COMMA_EXPR, CAAR(n), CDDR(n));
                  ));
                  goto use_tmp1;
                }
              }
            }
          }
        }
      }
    } else if (CAR(n)->token == F_LOR) {
      if (!CAAR(n)) {
      } else {
        if (!CDAR(n)) {
        } else {
          if ((node_is_true(CDAR(n)))) {
            if (!CDR(n)) {
            } else {
              if (CDR(n)->token == ':') {
                DBG("Match: ""'?'{831}(F_LOR{832}(0 = +{833}, +{834}[node_is_true(CDAR(n))]), ':'{835}(1 = *{836}, *))""\n");
                DBG("=> ""F_COMMA_EXPR{838}""\n");
                {
                  ADD_NODE_REF2(CAAR(n),
                  ADD_NODE_REF2(CADR(n),
                    tmp1 = mknode(F_COMMA_EXPR, CAAR(n), CADR(n));
                  ));
                  goto use_tmp1;
                }
              }
            }
          }
        }
      }
    }
    if (CDR(n)->token == ':') {
      if (!CADR(n)) {
        if (!CDDR(n)) {
          DBG("Match: ""'?'{791}(0 = *{792}, ':'{793}(-{794}, -{795}))""\n");
          DBG("=> ""0 = *{796}""\n");
          goto use_car;
        }
      } else if (!CDDR(n)) {
      } else {
        if (CDDR(n) == CADR(n)) {
          DBG("Match: ""'?'{841}(0 = *{842}, ':'{843}(1 = *{844}, $CADR(n)$))""\n");
          DBG("=> ""F_COMMA_EXPR{845}""\n");
          {
            ADD_NODE_REF2(CAR(n),
            ADD_NODE_REF2(CADR(n),
              tmp1 = mknode(F_COMMA_EXPR, CAR(n), CADR(n));
            ));
            goto use_tmp1;
          }
        }
        {
          if (CADR(n)->token == F_COMMA_EXPR) {
            if (!CDDR(n)) {
            } else {
              if (CDDR(n) == CDADR(n)) {
                DBG("Match: ""'?'{848}(0 = *{849}, ':'{850}(F_COMMA_EXPR{851}(1 = *{852}, 2 = *{853}), $CDADR(n)$))""\n");
                DBG("=> ""F_COMMA_EXPR{854}""\n");
                {
                  ADD_NODE_REF2(CAR(n),
                  ADD_NODE_REF2(CAADR(n),
                  ADD_NODE_REF2(CDADR(n),
                    tmp1 = mknode(F_COMMA_EXPR, mknode('?', CAR(n), mknode(':', CAADR(n), 0)), CDADR(n));
                  )));
                  goto use_tmp1;
                }
              }
              {
                if (CDDR(n)->token == F_COMMA_EXPR) {
                  {
                    if (CDDDR(n) == CDADR(n)) {
                      DBG("Match: ""'?'{874}(0 = *{875}, ':'{876}(F_COMMA_EXPR{877}(1 = *{878}, 2 = *{879}), F_COMMA_EXPR{880}(3 = *{881}, $CDADR(n)$)))""\n");
                      DBG("=> ""F_COMMA_EXPR{882}""\n");
                      {
                        ADD_NODE_REF2(CAR(n),
                        ADD_NODE_REF2(CAADR(n),
                        ADD_NODE_REF2(CADDR(n),
                        ADD_NODE_REF2(CDADR(n),
                          tmp1 = mknode(F_COMMA_EXPR, mknode('?', CAR(n), mknode(':', CAADR(n), CADDR(n))), CDADR(n));
                        ))));
                        goto use_tmp1;
                      }
                    }
                  }
                }
              }
            }
          }
          if (CDDR(n)->token == F_COMMA_EXPR) {
            {
              if (CDDDR(n) == CADR(n)) {
                DBG("Match: ""'?'{861}(0 = *{862}, ':'{863}(1 = *{864}, F_COMMA_EXPR{865}(2 = *{866}, $CADR(n)$)))""\n");
                DBG("=> ""F_COMMA_EXPR{867}""\n");
                {
                  ADD_NODE_REF2(CAR(n),
                  ADD_NODE_REF2(CADDR(n),
                  ADD_NODE_REF2(CADR(n),
                    tmp1 = mknode(F_COMMA_EXPR, mknode('?', CAR(n), mknode(':', 0, CADDR(n))), CADR(n));
                  )));
                  goto use_tmp1;
                }
              }
            }
          }
          if (!CDDR(n)) {
          } else {
            if (((pike_types_le(CADR(n)->type, void_type_string, 0, 0) !=
		     pike_types_le(CDDR(n)->type, void_type_string, 0, 0)))) {
              DBG("Match: ""'?'{889}(*, ':'{891}(0 = +{892}, 1 = +{893}[(pike_types_le(CADR(n)->type, void_type_string, 0, 0) !=\n"
              "\t\t     pike_types_le(CDDR(n)->type, void_type_string, 0, 0))]))""\n");
              {
                yytype_report(REPORT_ERROR,
              		CADR(n)->current_file, CADR(n)->line_number, CADR(n)->type,
              		CDDR(n)->current_file, CDDR(n)->line_number, CDDR(n)->type,
              		0, "The arguments to ?: may not be void.");
              }
            }
          }
        }
      }
    }
    if (( node_is_tossable(CAR(n)) )) {
      if (!CDR(n)) {
      } else {
        if (CDR(n)->token == ':') {
          if (!CADR(n)) {
          } else {
            if (CADR(n)->token == F_RETURN) {
              {
                if (CAADR(n) == CAR(n)) {
                  DBG("Match: ""'?'{1458}(0 = +{1459}[ node_is_tossable(CAR(n)) ], ':'{1460}(F_RETURN{1461}($CAR(n)$, 2 = *{1462}), 1 = *{1463}))""\n");
                  DBG("=> ""F_COMMA_EXPR{1464}""\n");
                  {
                    ADD_NODE_REF2(CAR(n),
                    ADD_NODE_REF2(CDADR(n),
                    ADD_NODE_REF2(CDDR(n),
                      tmp1 = mknode(F_COMMA_EXPR, mknode(F_RETURN_IF_TRUE, CAR(n), CDADR(n)), CDDR(n));
                    )));
                    goto use_tmp1;
                  }
                }
              }
            }
          }
        }
      }
    }
    if ((node_is_false(CAR(n)))) {
      if (!CDR(n)) {
      } else {
        if (CDR(n)->token == ':') {
          DBG("Match: ""'?'{815}(+{816}[node_is_false(CAR(n))], ':'{817}(*, 0 = *{819}))""\n");
          DBG("=> ""0 = *{820}""\n");
          {
            ADD_NODE_REF2(CDDR(n),
              tmp1 = CDDR(n);
            );
            goto use_tmp1;
          }
        }
      }
    }
    if ((node_is_true(CAR(n)))) {
      if (!CDR(n)) {
      } else {
        if (CDR(n)->token == ':') {
          DBG("Match: ""'?'{809}(+{810}[node_is_true(CAR(n))], ':'{811}(0 = *{812}, *))""\n");
          DBG("=> ""0 = *{814}""\n");
          {
            ADD_NODE_REF2(CADR(n),
              tmp1 = CADR(n);
            );
            goto use_tmp1;
          }
        }
      }
    }
  }
  break;

case F_ADD_EQ:
  if (!CAR(n)) {
  } else if (!CDR(n)) {
  } else {
    if (CDR(n)->token == F_APPLY) {
      if (!CADR(n)) {
      } else {
        if (CADR(n)->token == F_CONSTANT) {
          if ((TYPEOF(CADR(n)->u.sval) == T_FUNCTION) &&
              (SUBTYPEOF(CADR(n)->u.sval) == FUNCTION_BUILTIN) &&
              (CADR(n)->u.sval.u.efun->function == debug_f_aggregate)) {
            DBG("Match: ""F_ADD_EQ{1004}(0 = *{1005}, F_APPLY{1006}(F_CONSTANT{1007}[TYPEOF(CADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CADR(n)->u.sval) == FUNCTION_BUILTIN][CADR(n)->u.sval.u.efun->function == debug_f_aggregate], 1 = *{1008}))""\n");
            DBG("=> ""F_APPEND_ARRAY{1009}""\n");
            {
              ADD_NODE_REF2(CAR(n),
              ADD_NODE_REF2(CDDR(n),
                tmp1 = mknode(F_APPEND_ARRAY, CAR(n), CDDR(n));
              ));
              goto use_tmp1;
            }
          }
          if ((TYPEOF(CADR(n)->u.sval) == T_FUNCTION) &&
              (SUBTYPEOF(CADR(n)->u.sval) == FUNCTION_BUILTIN) &&
              (CADR(n)->u.sval.u.efun->function == f_aggregate_mapping)) {
            DBG("Match: ""F_ADD_EQ{1012}(0 = *{1013}, F_APPLY{1014}(F_CONSTANT{1015}[TYPEOF(CADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CADR(n)->u.sval) == FUNCTION_BUILTIN][CADR(n)->u.sval.u.efun->function == f_aggregate_mapping], 1 = *{1016}))""\n");
            DBG("=> ""F_APPEND_MAPPING{1017}""\n");
            {
              ADD_NODE_REF2(CAR(n),
              ADD_NODE_REF2(CDDR(n),
                tmp1 = mknode(F_APPEND_MAPPING, CAR(n), CDDR(n));
              ));
              goto use_tmp1;
            }
          }
        }
      }
    } else if (CDR(n)->token == F_CONSTANT) {
      if ((TYPEOF(CDR(n)->u.sval) == T_INT) &&
          ((CDR(n)->u.sval.u.integer) == -1)) {
        DBG("Match: ""F_ADD_EQ{982}(0 = *{983}, 1 = F_CONSTANT{984}[TYPEOF(CDR(n)->u.sval) == T_INT][(CDR(n)->u.sval.u.integer) == -1])""\n");
        DBG("=> ""F_DEC{985}""\n");
        {
          ADD_NODE_REF2(CAR(n),
            tmp1 = mknode(F_DEC, CAR(n), mkintnode(1));
          );
          goto use_tmp1;
        }
      }
      if ((TYPEOF(CDR(n)->u.sval) == T_INT) &&
          ((CDR(n)->u.sval.u.integer) == 1)) {
        DBG("Match: ""F_ADD_EQ{976}(0 = *{977}, 1 = F_CONSTANT{978}[TYPEOF(CDR(n)->u.sval) == T_INT][(CDR(n)->u.sval.u.integer) == 1])""\n");
        DBG("=> ""F_INC{979}""\n");
        {
          ADD_NODE_REF2(CAR(n),
            tmp1 = mknode(F_INC, CAR(n), mkintnode(1));
          );
          goto use_tmp1;
        }
      }
    }
    if (( CAR(n)->token != F_AUTO_MAP_MARKER )) {
      if (!CDR(n)) {
      } else {
        if (CDR(n)->token == F_CONSTANT) {
          if ((TYPEOF(CDR(n)->u.sval) == T_INT) &&
              (!(CDR(n)->u.sval.u.integer))) {
            DBG("Match: ""F_ADD_EQ{972}(0 = +{973}[ CAR(n)->token != F_AUTO_MAP_MARKER ], 1 = F_CONSTANT{974}[TYPEOF(CDR(n)->u.sval) == T_INT][!(CDR(n)->u.sval.u.integer)])""\n");
            DBG("=> ""0 = *{975}""\n");
            goto use_car;
          }
        }
      }
    }
    DBG("Match: ""F_ADD_EQ{1469}(0 = +{1470}, 1 = *{1471})""\n");
    {
      struct pike_type *type = CAR(n)->type;
      int oper = ((CAR(n)->tree_info&(OPT_SIDE_EFFECT|OPT_ASSIGNMENT)) ||
    	      depend_p(CAR(n), CDR(n))) ? F_ASSIGN_SELF : F_ASSIGN;
      
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CDR(n),
        tmp1 = mknode( oper, CAR(n), mksoftcastnode(type,mkopernode( "`+", CAR(n), CDR(n) )));
      )));
      goto use_tmp1;
    }
  }
  break;

case F_AND_EQ:
  if (!CAR(n)) {
  } else {
    DBG("Match: ""F_AND_EQ{1475}(0 = +{1476}, 1 = *{1477})""\n");
    {
      struct pike_type *type = CAR(n)->type;
      int oper = ((CAR(n)->tree_info&(OPT_SIDE_EFFECT|OPT_ASSIGNMENT)) ||
    	      depend_p(CAR(n), CDR(n))) ? F_ASSIGN_SELF : F_ASSIGN;
      
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CDR(n),
        tmp1 = mknode( oper, CAR(n), mksoftcastnode(type,mkopernode( "`&", CAR(n), CDR(n) )));
      )));
      goto use_tmp1;
    }
  }
  break;

case F_APPLY:
  if (!CAR(n)) {
    DBG("Match: ""F_APPLY{6}(-{7}, *)""\n");
    DBG("=> ""F_COMMA_EXPR{9}""\n");
    {
      ADD_NODE_REF2(CDR(n),
        tmp1 = mknode(F_COMMA_EXPR, mknode(F_POP_VALUE, CDR(n), 0), mkintnode(0));
      );
      goto use_tmp1;
    }
  } else {
    if (CAR(n)->token == F_CONSTANT) {
      if ((TYPEOF(CAR(n)->u.sval) == T_FUNCTION) &&
          (SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN) &&
          (CAR(n)->u.sval.u.efun->function == f_add)) {
        if (!CDR(n)) {
        } else {
          if (CDR(n)->token == F_ARG_LIST) {
            if (!CADR(n)) {
            } else {
              if (CADR(n)->token == F_APPLY) {
                if (!CAADR(n)) {
                } else {
                  if (CAADR(n)->token == F_CONSTANT) {
                    if ((TYPEOF(CAADR(n)->u.sval) == T_FUNCTION) &&
                        (SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN) &&
                        (CAADR(n)->u.sval.u.efun->function == f_add)) {
                      DBG("Match: ""F_APPLY{117}(0 = F_CONSTANT{118}[TYPEOF(CAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_add], 2 = F_ARG_LIST{119}(F_APPLY{120}(F_CONSTANT{121}[TYPEOF(CAADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN][CAADR(n)->u.sval.u.efun->function == f_add], 1 = *{122}), 3 = *{123}))""\n");
                      {
                          node *arglist = CDR(n);
                          ADD_NODE_REF2(CDADR(n),
                          ADD_NODE_REF2(CDDR(n),
                      		  _CDR(n) = mknode(F_ARG_LIST, CDADR(n), CDDR(n))));
                          _CDR(n)->parent = NULL;
                          fix_type_field(_CDR(n));
                          free_node(arglist);
#ifdef PIKE_DEBUG
                          if (l_flag > 4) {
                            fprintf(stderr, "Result:    ");
                            print_tree(n);
                          }
#endif /* PIKE_DEBUG */
                          continue;
                        }
                    }
                  }
                }
              }
            }
          }
        }
      }
      if ((TYPEOF(CAR(n)->u.sval) == T_FUNCTION) &&
          (SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN) &&
          (CAR(n)->u.sval.u.efun->function == f_eq)) {
        if (!CDR(n)) {
        } else {
          if (CDR(n)->token == F_ARG_LIST) {
            if (!CADR(n)) {
            } else {
              if (CADR(n)->token == F_APPLY) {
                if (!CAADR(n)) {
                } else {
                  if (CAADR(n)->token == F_CONSTANT) {
                    if ((TYPEOF(CAADR(n)->u.sval) == T_FUNCTION) &&
                        (SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN) &&
                        (CAADR(n)->u.sval.u.efun->function == f_search)) {
                      if (!CDADR(n)) {
                      } else {
                        if (CDADR(n)->token == F_ARG_LIST) {
                          if (!CADADR(n)) {
                          } else {
                            if (CADADR(n)->token == F_APPLY) {
                              if (!CAADADR(n)) {
                              } else {
                                if (CAADADR(n)->token == F_CONSTANT) {
                                  if ((TYPEOF(CAADADR(n)->u.sval) == T_FUNCTION) &&
                                      (SUBTYPEOF(CAADADR(n)->u.sval) == FUNCTION_BUILTIN) &&
                                      (CAADADR(n)->u.sval.u.efun->function == f_indices)) {
                                    if (!CDADADR(n)) {
                                    } else {
                                      if ((pike_types_le(CDADADR(n)->type, mapping_type_string, 0, 0))) {
                                        if (!CDDR(n)) {
                                        } else {
                                          if (CDDR(n)->token == F_CONSTANT) {
                                            if ((TYPEOF(CDDR(n)->u.sval) == T_INT) &&
                                                (CDDR(n)->u.sval.u.integer == -1)) {
                                              DBG("Match: ""F_APPLY{62}(F_CONSTANT{63}[TYPEOF(CAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_eq], F_ARG_LIST{64}(F_APPLY{65}(F_CONSTANT{66}[TYPEOF(CAADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN][CAADR(n)->u.sval.u.efun->function == f_search], F_ARG_LIST{67}(F_APPLY{68}(F_CONSTANT{69}[TYPEOF(CAADADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAADADR(n)->u.sval) == FUNCTION_BUILTIN][CAADADR(n)->u.sval.u.efun->function == f_indices], 0 = +{70}[pike_types_le(CDADADR(n)->type, mapping_type_string, 0, 0)]), 1 = *{71})), F_CONSTANT{72}[TYPEOF(CDDR(n)->u.sval) == T_INT][CDDR(n)->u.sval.u.integer == -1]))""\n");
                                              {
                                                
                                                ADD_NODE_REF2(CDADADR(n),
                                                ADD_NODE_REF2(CDDADR(n),
                                                  tmp1 = mkefuncallnode("zero_type",mknode(F_ARG_LIST, CDADADR(n), CDDADR(n)));
                                                ));
                                                goto use_tmp1;
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
      if ((TYPEOF(CAR(n)->u.sval) == T_FUNCTION) &&
          (SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN) &&
          (CAR(n)->u.sval.u.efun->function == f_ge)) {
        if (!CDR(n)) {
        } else {
          if (CDR(n)->token == F_ARG_LIST) {
            if (!CADR(n)) {
            } else {
              if (CADR(n)->token == F_APPLY) {
                if (!CAADR(n)) {
                } else {
                  if (CAADR(n)->token == F_CONSTANT) {
                    if ((TYPEOF(CAADR(n)->u.sval) == T_FUNCTION) &&
                        (SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN) &&
                        (CAADR(n)->u.sval.u.efun->function == f_search)) {
                      if (!CDADR(n)) {
                      } else {
                        if (CDADR(n)->token == F_ARG_LIST) {
                          if (!CADADR(n)) {
                          } else {
                            if (CADADR(n)->token == F_APPLY) {
                              if (!CAADADR(n)) {
                              } else {
                                if (CAADADR(n)->token == F_CONSTANT) {
                                  if ((TYPEOF(CAADADR(n)->u.sval) == T_FUNCTION) &&
                                      (SUBTYPEOF(CAADADR(n)->u.sval) == FUNCTION_BUILTIN) &&
                                      (CAADADR(n)->u.sval.u.efun->function == f_indices)) {
                                    if (!CDADADR(n)) {
                                    } else {
                                      if ((pike_types_le(CDADADR(n)->type, mapping_type_string, 0, 0))) {
                                        if (!CDDR(n)) {
                                        } else {
                                          if (CDDR(n)->token == F_CONSTANT) {
                                            if ((TYPEOF(CDDR(n)->u.sval) == T_INT) &&
                                                (!CDDR(n)->u.sval.u.integer)) {
                                              DBG("Match: ""F_APPLY{73}(F_CONSTANT{74}[TYPEOF(CAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_ge], F_ARG_LIST{75}(F_APPLY{76}(F_CONSTANT{77}[TYPEOF(CAADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN][CAADR(n)->u.sval.u.efun->function == f_search], F_ARG_LIST{78}(F_APPLY{79}(F_CONSTANT{80}[TYPEOF(CAADADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAADADR(n)->u.sval) == FUNCTION_BUILTIN][CAADADR(n)->u.sval.u.efun->function == f_indices], 0 = +{81}[pike_types_le(CDADADR(n)->type, mapping_type_string, 0, 0)]), 1 = *{82})), F_CONSTANT{83}[TYPEOF(CDDR(n)->u.sval) == T_INT][!CDDR(n)->u.sval.u.integer]))""\n");
                                              {
                                                
                                                ADD_NODE_REF2(CDADADR(n),
                                                ADD_NODE_REF2(CDDADR(n),
                                                  tmp1 = mknode(F_NOT,mkefuncallnode("zero_type",mknode(F_ARG_LIST, CDADADR(n), CDDADR(n))),0);
                                                ));
                                                goto use_tmp1;
                                              }
                                            }
                                            if ((TYPEOF(CDDR(n)->u.sval) == T_INT) &&
                                                (CDDR(n)->u.sval.u.integer == -1)) {
                                              DBG("Match: ""F_APPLY{84}(F_CONSTANT{85}[TYPEOF(CAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_ge], F_ARG_LIST{86}(F_APPLY{87}(F_CONSTANT{88}[TYPEOF(CAADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN][CAADR(n)->u.sval.u.efun->function == f_search], F_ARG_LIST{89}(F_APPLY{90}(F_CONSTANT{91}[TYPEOF(CAADADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAADADR(n)->u.sval) == FUNCTION_BUILTIN][CAADADR(n)->u.sval.u.efun->function == f_indices], 0 = +{92}[pike_types_le(CDADADR(n)->type, mapping_type_string, 0, 0)]), 1 = *{93})), F_CONSTANT{94}[TYPEOF(CDDR(n)->u.sval) == T_INT][CDDR(n)->u.sval.u.integer == -1]))""\n");
                                              {
                                                
                                                ADD_NODE_REF2(CDADADR(n),
                                                ADD_NODE_REF2(CDDADR(n),
                                                  tmp1 = mknode(F_NOT,mkefuncallnode("zero_type",mknode(F_ARG_LIST, CDADADR(n), CDDADR(n))),0);
                                                ));
                                                goto use_tmp1;
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
      if ((TYPEOF(CAR(n)->u.sval) == T_FUNCTION) &&
          (SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN) &&
          (CAR(n)->u.sval.u.efun->function == f_lt)) {
        if (!CDR(n)) {
        } else {
          if (CDR(n)->token == F_ARG_LIST) {
            if (!CADR(n)) {
            } else {
              if (CADR(n)->token == F_APPLY) {
                if (!CAADR(n)) {
                } else {
                  if (CAADR(n)->token == F_CONSTANT) {
                    if ((TYPEOF(CAADR(n)->u.sval) == T_FUNCTION) &&
                        (SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN) &&
                        (CAADR(n)->u.sval.u.efun->function == f_search)) {
                      if (!CDADR(n)) {
                      } else {
                        if (CDADR(n)->token == F_ARG_LIST) {
                          if (!CADADR(n)) {
                          } else {
                            if (CADADR(n)->token == F_APPLY) {
                              if (!CAADADR(n)) {
                              } else {
                                if (CAADADR(n)->token == F_CONSTANT) {
                                  if ((TYPEOF(CAADADR(n)->u.sval) == T_FUNCTION) &&
                                      (SUBTYPEOF(CAADADR(n)->u.sval) == FUNCTION_BUILTIN) &&
                                      (CAADADR(n)->u.sval.u.efun->function == f_indices)) {
                                    if (!CDADADR(n)) {
                                    } else {
                                      if ((pike_types_le(CDADADR(n)->type, mapping_type_string, 0, 0))) {
                                        if (!CDDR(n)) {
                                        } else {
                                          if (CDDR(n)->token == F_CONSTANT) {
                                            if ((TYPEOF(CDDR(n)->u.sval) == T_INT) &&
                                                (!CDDR(n)->u.sval.u.integer)) {
                                              DBG("Match: ""F_APPLY{51}(F_CONSTANT{52}[TYPEOF(CAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_lt], F_ARG_LIST{53}(F_APPLY{54}(F_CONSTANT{55}[TYPEOF(CAADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN][CAADR(n)->u.sval.u.efun->function == f_search], F_ARG_LIST{56}(F_APPLY{57}(F_CONSTANT{58}[TYPEOF(CAADADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAADADR(n)->u.sval) == FUNCTION_BUILTIN][CAADADR(n)->u.sval.u.efun->function == f_indices], 0 = +{59}[pike_types_le(CDADADR(n)->type, mapping_type_string, 0, 0)]), 1 = *{60})), F_CONSTANT{61}[TYPEOF(CDDR(n)->u.sval) == T_INT][!CDDR(n)->u.sval.u.integer]))""\n");
                                              {
                                                
                                                ADD_NODE_REF2(CDADADR(n),
                                                ADD_NODE_REF2(CDDADR(n),
                                                  tmp1 = mkefuncallnode("zero_type",mknode(F_ARG_LIST, CDADADR(n), CDDADR(n)));
                                                ));
                                                goto use_tmp1;
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
      if ((TYPEOF(CAR(n)->u.sval) == T_FUNCTION) &&
          (SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN) &&
          (CAR(n)->u.sval.u.efun->function == f_minus)) {
        if (!CDR(n)) {
        } else {
          if (CDR(n)->token == F_ARG_LIST) {
            if (!CADR(n)) {
            } else {
              if (CADR(n)->token == F_APPLY) {
                if (!CAADR(n)) {
                } else {
                  if (CAADR(n)->token == F_CONSTANT) {
                    if ((TYPEOF(CAADR(n)->u.sval) == T_FUNCTION) &&
                        (SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN) &&
                        (CAADR(n)->u.sval.u.efun->function == f_minus)) {
                      if (!CDADR(n)) {
                      } else {
                        if (CDADR(n)->token == F_ARG_LIST) {
                          if (!CADADR(n)) {
                          } else {
                            if (!CDDADR(n)) {
                            } else {
                              DBG("Match: ""F_APPLY{124}(0 = F_CONSTANT{125}[TYPEOF(CAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_minus], 2 = F_ARG_LIST{126}(F_APPLY{127}(F_CONSTANT{128}[TYPEOF(CAADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN][CAADR(n)->u.sval.u.efun->function == f_minus], 1 = F_ARG_LIST{129}(+{130}, +{131})), 3 = *{132}))""\n");
                              {
                                  node *arglist = CDR(n);
                                  ADD_NODE_REF2(CDADR(n),
                                  ADD_NODE_REF2(CDDR(n),
                              		  _CDR(n) = mknode(F_ARG_LIST, CDADR(n), CDDR(n))));
                                  _CDR(n)->parent = NULL;
                                  fix_type_field(_CDR(n));
                                  free_node(arglist);
#ifdef PIKE_DEBUG
                                  if (l_flag > 4) {
                                    fprintf(stderr, "Result:    ");
                                    print_tree(n);
                                  }
#endif /* PIKE_DEBUG */
                                  continue;
                                }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
      if ((TYPEOF(CAR(n)->u.sval) == T_FUNCTION) &&
          (SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN) &&
          (CAR(n)->u.sval.u.efun->function == f_multiply)) {
        if (!CDR(n)) {
        } else {
          if (CDR(n)->token == F_ARG_LIST) {
            if (!CADR(n)) {
            } else {
              if (CADR(n)->token == F_APPLY) {
                if (!CAADR(n)) {
                } else {
                  if (CAADR(n)->token == F_CONSTANT) {
                    if ((TYPEOF(CAADR(n)->u.sval) == T_FUNCTION) &&
                        (SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN) &&
                        (CAADR(n)->u.sval.u.efun->function == f_multiply)) {
                      DBG("Match: ""F_APPLY{133}(0 = F_CONSTANT{134}[TYPEOF(CAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_multiply], 2 = F_ARG_LIST{135}(F_APPLY{136}(F_CONSTANT{137}[TYPEOF(CAADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN][CAADR(n)->u.sval.u.efun->function == f_multiply], 1 = *{138}), 3 = *{139}))""\n");
                      {
                          node *arglist = CDR(n);
                          ADD_NODE_REF2(CDADR(n),
                          ADD_NODE_REF2(CDDR(n),
                      		  _CDR(n) = mknode(F_ARG_LIST, CDADR(n), CDDR(n))));
                          _CDR(n)->parent = NULL;
                          fix_type_field(_CDR(n));
                          free_node(arglist);
#ifdef PIKE_DEBUG
                          if (l_flag > 4) {
                            fprintf(stderr, "Result:    ");
                            print_tree(n);
                          }
#endif /* PIKE_DEBUG */
                          continue;
                        }
                    }
                  }
                }
              }
            }
          }
        }
      }
      if ((TYPEOF(CAR(n)->u.sval) == T_FUNCTION) &&
          (SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN) &&
          (CAR(n)->u.sval.u.efun->function == f_not)) {
        if (!CDR(n)) {
        } else {
          if (CDR(n)->token == F_ARG_LIST) {
            if (!CADR(n)) {
              DBG("Match: ""F_APPLY{894}(F_CONSTANT{895}[TYPEOF(CAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_not], F_ARG_LIST{896}(-{897}, *))""\n");
              DBG("=> ""1 = T_INT{899}""\n");
              {
                tmp1 = mkintnode(1);
                goto use_tmp1;
              }
            } else {
              if (CADR(n)->token == F_APPLY) {
                if (!CAADR(n)) {
                } else {
                  if (CAADR(n)->token == F_CONSTANT) {
                    if ((TYPEOF(CAADR(n)->u.sval) == T_FUNCTION) &&
                        (SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN) &&
                        (CAADR(n)->u.sval.u.efun->function == f_eq)) {
                      if (!CDADR(n)) {
                      } else {
                        if (CDADR(n)->token == F_ARG_LIST) {
                          DBG("Match: ""F_APPLY{948}(F_CONSTANT{949}[TYPEOF(CAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_not], F_ARG_LIST{950}(F_APPLY{951}(F_CONSTANT{952}[TYPEOF(CAADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN][CAADR(n)->u.sval.u.efun->function == f_eq], F_ARG_LIST{953}(0 = *{954}, 1 = *{955})), *))""\n");
                          DBG("=> ""F_NE{957}""\n");
                          {
                            ADD_NODE_REF2(CADADR(n),
                            ADD_NODE_REF2(CDDADR(n),
                              tmp1 = mknode(F_NE, CADADR(n), CDDADR(n));
                            ));
                            goto use_tmp1;
                          }
                        }
                      }
                    }
                    if ((TYPEOF(CAADR(n)->u.sval) == T_FUNCTION) &&
                        (SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN) &&
                        (CAADR(n)->u.sval.u.efun->function == f_ge)) {
                      if (!CDADR(n)) {
                      } else {
                        if (CDADR(n)->token == F_ARG_LIST) {
                          if (!CADADR(n)) {
                          } else {
                            if ((pike_types_le(CADADR(n)->type, int_type_string, 0, 0))) {
                              if (!CDDADR(n)) {
                              } else {
                                if ((pike_types_le(CDDADR(n)->type, int_type_string, 0, 0))) {
                                  DBG("Match: ""F_APPLY{936}(F_CONSTANT{937}[TYPEOF(CAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_not], F_ARG_LIST{938}(F_APPLY{939}(F_CONSTANT{940}[TYPEOF(CAADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN][CAADR(n)->u.sval.u.efun->function == f_ge], F_ARG_LIST{941}(0 = +{942}[pike_types_le(CADADR(n)->type, int_type_string, 0, 0)], 1 = +{943}[pike_types_le(CDDADR(n)->type, int_type_string, 0, 0)])), *))""\n");
                                  DBG("=> ""F_LT{945}""\n");
                                  {
                                    ADD_NODE_REF2(CADADR(n),
                                    ADD_NODE_REF2(CDDADR(n),
                                      tmp1 = mknode(F_LT, CADADR(n), CDDADR(n));
                                    ));
                                    goto use_tmp1;
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                    if ((TYPEOF(CAADR(n)->u.sval) == T_FUNCTION) &&
                        (SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN) &&
                        (CAADR(n)->u.sval.u.efun->function == f_gt)) {
                      if (!CDADR(n)) {
                      } else {
                        if (CDADR(n)->token == F_ARG_LIST) {
                          if (!CADADR(n)) {
                          } else {
                            if ((pike_types_le(CADADR(n)->type, int_type_string, 0, 0))) {
                              if (!CDDADR(n)) {
                              } else {
                                if ((pike_types_le(CDDADR(n)->type, int_type_string, 0, 0))) {
                                  DBG("Match: ""F_APPLY{912}(F_CONSTANT{913}[TYPEOF(CAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_not], F_ARG_LIST{914}(F_APPLY{915}(F_CONSTANT{916}[TYPEOF(CAADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN][CAADR(n)->u.sval.u.efun->function == f_gt], F_ARG_LIST{917}(0 = +{918}[pike_types_le(CADADR(n)->type, int_type_string, 0, 0)], 1 = +{919}[pike_types_le(CDDADR(n)->type, int_type_string, 0, 0)])), *))""\n");
                                  DBG("=> ""F_LE{921}""\n");
                                  {
                                    ADD_NODE_REF2(CADADR(n),
                                    ADD_NODE_REF2(CDDADR(n),
                                      tmp1 = mknode(F_LE, CADADR(n), CDDADR(n));
                                    ));
                                    goto use_tmp1;
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                    if ((TYPEOF(CAADR(n)->u.sval) == T_FUNCTION) &&
                        (SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN) &&
                        (CAADR(n)->u.sval.u.efun->function == f_le)) {
                      if (!CDADR(n)) {
                      } else {
                        if (CDADR(n)->token == F_ARG_LIST) {
                          if (!CADADR(n)) {
                          } else {
                            if ((pike_types_le(CADADR(n)->type, int_type_string, 0, 0))) {
                              if (!CDDADR(n)) {
                              } else {
                                if ((pike_types_le(CDDADR(n)->type, int_type_string, 0, 0))) {
                                  DBG("Match: ""F_APPLY{924}(F_CONSTANT{925}[TYPEOF(CAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_not], F_ARG_LIST{926}(F_APPLY{927}(F_CONSTANT{928}[TYPEOF(CAADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN][CAADR(n)->u.sval.u.efun->function == f_le], F_ARG_LIST{929}(0 = +{930}[pike_types_le(CADADR(n)->type, int_type_string, 0, 0)], 1 = +{931}[pike_types_le(CDDADR(n)->type, int_type_string, 0, 0)])), *))""\n");
                                  DBG("=> ""F_GT{933}""\n");
                                  {
                                    ADD_NODE_REF2(CADADR(n),
                                    ADD_NODE_REF2(CDDADR(n),
                                      tmp1 = mknode(F_GT, CADADR(n), CDDADR(n));
                                    ));
                                    goto use_tmp1;
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                    if ((TYPEOF(CAADR(n)->u.sval) == T_FUNCTION) &&
                        (SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN) &&
                        (CAADR(n)->u.sval.u.efun->function == f_lt)) {
                      if (!CDADR(n)) {
                      } else {
                        if (CDADR(n)->token == F_ARG_LIST) {
                          if (!CADADR(n)) {
                          } else {
                            if ((pike_types_le(CADADR(n)->type, int_type_string, 0, 0))) {
                              if (!CDDADR(n)) {
                              } else {
                                if ((pike_types_le(CDDADR(n)->type, int_type_string, 0, 0))) {
                                  DBG("Match: ""F_APPLY{900}(F_CONSTANT{901}[TYPEOF(CAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_not], F_ARG_LIST{902}(F_APPLY{903}(F_CONSTANT{904}[TYPEOF(CAADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN][CAADR(n)->u.sval.u.efun->function == f_lt], F_ARG_LIST{905}(0 = +{906}[pike_types_le(CADADR(n)->type, int_type_string, 0, 0)], 1 = +{907}[pike_types_le(CDDADR(n)->type, int_type_string, 0, 0)])), *))""\n");
                                  DBG("=> ""F_GE{909}""\n");
                                  {
                                    ADD_NODE_REF2(CADADR(n),
                                    ADD_NODE_REF2(CDDADR(n),
                                      tmp1 = mknode(F_GE, CADADR(n), CDDADR(n));
                                    ));
                                    goto use_tmp1;
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                    if ((TYPEOF(CAADR(n)->u.sval) == T_FUNCTION) &&
                        (SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN) &&
                        (CAADR(n)->u.sval.u.efun->function == f_ne)) {
                      if (!CDADR(n)) {
                      } else {
                        if (CDADR(n)->token == F_ARG_LIST) {
                          DBG("Match: ""F_APPLY{960}(F_CONSTANT{961}[TYPEOF(CAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_not], F_ARG_LIST{962}(F_APPLY{963}(F_CONSTANT{964}[TYPEOF(CAADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAADR(n)->u.sval) == FUNCTION_BUILTIN][CAADR(n)->u.sval.u.efun->function == f_ne], F_ARG_LIST{965}(0 = *{966}, 1 = *{967})), *))""\n");
                          DBG("=> ""F_EQ{969}""\n");
                          {
                            ADD_NODE_REF2(CADADR(n),
                            ADD_NODE_REF2(CDDADR(n),
                              tmp1 = mknode(F_EQ, CADADR(n), CDDADR(n));
                            ));
                            goto use_tmp1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
      if ((TYPEOF(CAR(n)->u.sval) == T_FUNCTION) &&
          (SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN) &&
          (CAR(n)->u.sval.u.efun->function == f_sizeof)) {
        if (!CDR(n)) {
        } else {
          if (CDR(n)->token == F_APPLY) {
            if (!CADR(n)) {
            } else {
              if (CADR(n)->token == F_CONSTANT) {
                if ((TYPEOF(CADR(n)->u.sval) == T_FUNCTION) &&
                    (SUBTYPEOF(CADR(n)->u.sval) == FUNCTION_BUILTIN) &&
                    (CADR(n)->u.sval.u.efun->function == f_multiply)) {
                  if (!CDDR(n)) {
                  } else {
                    if (CDDR(n)->token == F_ARG_LIST) {
                      if (!CADDR(n)) {
                      } else {
                        if ((!match_types(object_type_string, CADDR(n)->type))) {
                          if (!CDDDR(n)) {
                          } else {
                            if ((pike_types_le(CDDDR(n)->type, int_type_string, 0, 0))) {
                              DBG("Match: ""F_APPLY{37}(0 = F_CONSTANT{38}[TYPEOF(CAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_sizeof], F_APPLY{39}(1 = F_CONSTANT{40}[TYPEOF(CADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CADR(n)->u.sval) == FUNCTION_BUILTIN][CADR(n)->u.sval.u.efun->function == f_multiply], F_ARG_LIST{41}(2 = +{42}[!match_types(object_type_string, CADDR(n)->type)], 3 = +{43}[pike_types_le(CDDDR(n)->type, int_type_string, 0, 0)])))""\n");
                              DBG("=> ""F_APPLY{44}""\n");
                              {
                                ADD_NODE_REF2(CADR(n),
                                ADD_NODE_REF2(CAR(n),
                                ADD_NODE_REF2(CADDR(n),
                                ADD_NODE_REF2(CDDDR(n),
                                  tmp1 = mknode(F_APPLY, CADR(n), mknode(F_ARG_LIST, mknode(F_APPLY, CAR(n), CADDR(n)), CDDDR(n)));
                                ))));
                                goto use_tmp1;
                              }
                            }
                          }
                        }
                        if ((pike_types_le(CADDR(n)->type, int_type_string, 0, 0))) {
                          if (!CDDDR(n)) {
                          } else {
                            if ((!match_types(object_type_string, CDDDR(n)->type))) {
                              DBG("Match: ""F_APPLY{23}(0 = F_CONSTANT{24}[TYPEOF(CAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_sizeof], F_APPLY{25}(1 = F_CONSTANT{26}[TYPEOF(CADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CADR(n)->u.sval) == FUNCTION_BUILTIN][CADR(n)->u.sval.u.efun->function == f_multiply], F_ARG_LIST{27}(2 = +{28}[pike_types_le(CADDR(n)->type, int_type_string, 0, 0)], 3 = +{29}[!match_types(object_type_string, CDDDR(n)->type)])))""\n");
                              DBG("=> ""F_APPLY{30}""\n");
                              {
                                ADD_NODE_REF2(CADR(n),
                                ADD_NODE_REF2(CADDR(n),
                                ADD_NODE_REF2(CAR(n),
                                ADD_NODE_REF2(CDDDR(n),
                                  tmp1 = mknode(F_APPLY, CADR(n), mknode(F_ARG_LIST, CADDR(n), mknode(F_APPLY, CAR(n), CDDDR(n))));
                                ))));
                                goto use_tmp1;
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
      if ((TYPEOF(CAR(n)->u.sval) == T_FUNCTION) &&
          (SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN) &&
          (CAR(n)->u.sval.u.efun->optimize) &&
          ( (tmp1=CAR(n)->u.sval.u.efun->optimize(n)) )) {
        DBG("Match: ""0 = F_APPLY{0}(F_CONSTANT{1}[TYPEOF(CAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->optimize][ (tmp1=CAR(n)->u.sval.u.efun->optimize(n)) ], *)""\n");
        {
          goto use_tmp1;
        }
      }
      if ((TYPEOF(CAR(n)->u.sval) == T_PROGRAM) &&
          (CAR(n)->u.sval.u.program->optimize) &&
          ( (tmp1=CAR(n)->u.sval.u.program->optimize(n)) )) {
        DBG("Match: ""0 = F_APPLY{3}(F_CONSTANT{4}[TYPEOF(CAR(n)->u.sval) == T_PROGRAM][CAR(n)->u.sval.u.program->optimize][ (tmp1=CAR(n)->u.sval.u.program->optimize(n)) ], *)""\n");
        {
          goto use_tmp1;
        }
      }
    }
  }
  break;

case F_ARG_LIST:
  if (!CAR(n)) {
    DBG("Match: ""F_ARG_LIST{479}(-{480}, 0 = *{481})""\n");
    DBG("=> ""0 = *{482}""\n");
    goto use_cdr;
  } else if (!CDR(n)) {
    DBG("Match: ""F_ARG_LIST{483}(0 = *{484}, -{485})""\n");
    DBG("=> ""0 = *{486}""\n");
    goto use_car;
  } else {
    if (CAR(n)->token == F_BREAK) {
      if (!CDR(n)) {
      } else {
        if ((!(CDR(n)->tree_info & OPT_CASE))) {
          DBG("Match: ""F_ARG_LIST{513}(0 = F_BREAK{514}, +{515}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
          DBG("=> ""0 = *{516}""\n");
          goto use_car;
        }
      }
    } else if (CAR(n)->token == F_COMMA_EXPR) {
      if (!CDAR(n)) {
      } else {
        if (CDAR(n)->token == F_BREAK) {
          if (!CDR(n)) {
          } else {
            if ((!(CDR(n)->tree_info & OPT_CASE))) {
              DBG("Match: ""F_ARG_LIST{539}(0 = F_COMMA_EXPR{540}(*, F_BREAK{542}), +{543}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
              DBG("=> ""0 = *{544}""\n");
              goto use_car;
            }
          }
        } else if (CDAR(n)->token == F_CONTINUE) {
          if (!CDR(n)) {
          } else {
            if ((!(CDR(n)->tree_info & OPT_CASE))) {
              DBG("Match: ""F_ARG_LIST{533}(0 = F_COMMA_EXPR{534}(*, F_CONTINUE{536}), +{537}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
              DBG("=> ""0 = *{538}""\n");
              goto use_car;
            }
          }
        } else if (CDAR(n)->token == F_RETURN) {
          if (!CDDAR(n)) {
            if (!CDR(n)) {
            } else {
              if ((!(CDR(n)->tree_info & OPT_CASE))) {
                DBG("Match: ""F_ARG_LIST{517}(0 = F_COMMA_EXPR{518}(*, F_RETURN{520}(*, -{522})), +{523}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
                DBG("=> ""0 = *{524}""\n");
                goto use_car;
              }
            }
          } else {
            if (CDDAR(n)->token == F_CONSTANT) {
              if ((TYPEOF(CDDAR(n)->u.sval) == T_INT) &&
                  (!CDDAR(n)->u.sval.u.integer)) {
                if (!CDR(n)) {
                } else {
                  if ((!(CDR(n)->tree_info & OPT_CASE))) {
                    DBG("Match: ""F_ARG_LIST{525}(0 = F_COMMA_EXPR{526}(*, F_RETURN{528}(*, F_CONSTANT{530}[TYPEOF(CDDAR(n)->u.sval) == T_INT][!CDDAR(n)->u.sval.u.integer])), +{531}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
                    DBG("=> ""0 = *{532}""\n");
                    goto use_car;
                  }
                }
              }
            }
          }
        }
      }
    } else if (CAR(n)->token == F_CONTINUE) {
      if (!CDR(n)) {
      } else {
        if ((!(CDR(n)->tree_info & OPT_CASE))) {
          DBG("Match: ""F_ARG_LIST{509}(0 = F_CONTINUE{510}, +{511}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
          DBG("=> ""0 = *{512}""\n");
          goto use_car;
        }
      }
    } else if (CAR(n)->token == F_RETURN) {
      if (!CDAR(n)) {
        if (!CDR(n)) {
        } else {
          if ((!(CDR(n)->tree_info & OPT_CASE))) {
            DBG("Match: ""F_ARG_LIST{497}(0 = F_RETURN{498}(*, -{500}), +{501}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
            DBG("=> ""0 = *{502}""\n");
            goto use_car;
          }
        }
      } else {
        if (CDAR(n)->token == F_CONSTANT) {
          if ((TYPEOF(CDAR(n)->u.sval) == T_INT) &&
              (!CDAR(n)->u.sval.u.integer)) {
            if (!CDR(n)) {
            } else {
              if ((!(CDR(n)->tree_info & OPT_CASE))) {
                DBG("Match: ""F_ARG_LIST{503}(0 = F_RETURN{504}(*, F_CONSTANT{506}[TYPEOF(CDAR(n)->u.sval) == T_INT][!CDAR(n)->u.sval.u.integer]), +{507}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
                DBG("=> ""0 = *{508}""\n");
                goto use_car;
              }
            }
          }
        }
      }
    }
    if (CDR(n)->token == F_ARG_LIST) {
      DBG("Match: ""F_ARG_LIST{487}(0 = *{488}, F_ARG_LIST{489}(1 = *{490}, 2 = *{491}))""\n");
      DBG("=> ""F_ARG_LIST{492}""\n");
      {
        ADD_NODE_REF2(CAR(n),
        ADD_NODE_REF2(CADR(n),
        ADD_NODE_REF2(CDDR(n),
          tmp1 = mknode(F_ARG_LIST, mknode(F_ARG_LIST, CAR(n), CADR(n)), CDDR(n));
        )));
        goto use_tmp1;
      }
    }
  }
  break;

case F_ARROW:
  if (!CAR(n)) {
    DBG("Match: ""F_ARROW{1042}(-{1043}, *)""\n");
    DBG("=> ""F_COMMA_EXPR{1045}""\n");
    {
      ADD_NODE_REF2(CDR(n),
        tmp1 = mknode(F_COMMA_EXPR, mknode(F_POP_VALUE, CDR(n), 0), mkintnode(0));
      );
      goto use_tmp1;
    }
  } else {
    if (CAR(n)->token == F_CONSTANT) {
      if ((TYPEOF(CAR(n)->u.sval) == T_OBJECT) &&
          (CAR(n)->u.sval.u.object->prog)) {
        if (!CDR(n)) {
        } else {
          if (CDR(n)->token == F_CONSTANT) {
            if ((TYPEOF(CDR(n)->u.sval) == T_STRING)) {
              DBG("Match: ""F_ARROW{1050}(0 = F_CONSTANT{1051}[TYPEOF(CAR(n)->u.sval) == T_OBJECT][CAR(n)->u.sval.u.object->prog], 1 = F_CONSTANT{1052}[TYPEOF(CDR(n)->u.sval) == T_STRING])""\n");
              {
                /*
                if (find_identifier("`->", CAR(n)->u.sval.u.object->prog) == -1) {
                  int i = find_shared_string_identifier(CDR(n)->u.sval.u.string,
              					  CAR(n)->u.sval.u.object->prog);
                  if (i) {
                    struct identifier *id = ID_FROM_INT(CAR(n)->u.sval.u.object->prog, i);
                    if (IDENTIFIER_IS_VARIABLE(id->identifier_flags))
              	goto next_arrow_opt;
                  }
                  ref_push_object(CAR(n)->u.sval.u.object);
                  ref_push_string(CDR(n)->u.sval.u.string);
                  f_index(2);
                  tmp1 = mksvaluenode(sp-1);
                  pop_stack();
                  goto use_tmp1;
                }
               next_arrow_opt:
                ;
                */
              }
            }
          }
        }
      }
    }
  }
  break;

case F_ASSIGN:
  if (!CAR(n)) {
  } else {
    if (CAR(n)->token == F_ARRAY_LVALUE) {
      if (!CDAR(n)) {
        if (!CDR(n)) {
        } else {
          if (CDR(n)->token == F_APPLY) {
            if (!CADR(n)) {
            } else {
              if (CADR(n)->token == F_CONSTANT) {
                if ((TYPEOF(CADR(n)->u.sval) == T_FUNCTION) &&
                    (SUBTYPEOF(CADR(n)->u.sval) == FUNCTION_BUILTIN) &&
                    (CADR(n)->u.sval.u.efun->function == debug_f_aggregate)) {
                  if (!CDDR(n)) {
                  } else {
                    if ((count_args(CDDR(n)) >= 0)) {
                      DBG("Match: ""F_ASSIGN{462}(F_ARRAY_LVALUE{463}(1 = *{464}, -{465}), F_APPLY{466}(F_CONSTANT{467}[TYPEOF(CADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CADR(n)->u.sval) == FUNCTION_BUILTIN][CADR(n)->u.sval.u.efun->function == debug_f_aggregate], 0 = +{468}[count_args(CDDR(n)) >= 0]))""\n");
                      DBG("=> ""F_MULTI_ASSIGN{469}""\n");
                      {
                        ADD_NODE_REF2(CAAR(n),
                        ADD_NODE_REF2(CDDR(n),
                          tmp1 = mknode(F_MULTI_ASSIGN, CAAR(n), CDDR(n));
                        ));
                        goto use_tmp1;
                      }
                    }
                  }
                }
                if ((TYPEOF(CADR(n)->u.sval) == T_FUNCTION) &&
                    (SUBTYPEOF(CADR(n)->u.sval) == FUNCTION_BUILTIN) &&
                    (CADR(n)->u.sval.u.efun->function == f_allocate)) {
                  DBG("Match: ""F_ASSIGN{472}(F_ARRAY_LVALUE{473}(1 = *{474}, -{475}), 0 = F_APPLY{476}(F_CONSTANT{477}[TYPEOF(CADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CADR(n)->u.sval) == FUNCTION_BUILTIN][CADR(n)->u.sval.u.efun->function == f_allocate], *))""\n");
                  {
                      int cnt = 0;
                      node **arg1 = my_get_arg(&_CDR(CDR(n)), 0);
                      node **arg2 = my_get_arg(&_CDR(CDR(n)), 1);
                      if (arg1) {
                        node *res;
                        node *lvalues = CAAR(n);

                        if (arg2 && *arg2) {
                  	ADD_NODE_REF2(*arg2, res = *arg2;);
                        } else {
                  	res = mkintnode(0);
                        }
                        while (lvalues && (lvalues->token == F_LVALUE_LIST)) {
                  	ADD_NODE_REF2(CAR(lvalues),
                  		      res = mknode(F_ASSIGN, CAR(lvalues), res););
                  	lvalues = CDR(lvalues);
                  	cnt++;
                        }
                        if (lvalues) {
                  	ADD_NODE_REF2(lvalues, res = mknode(F_ASSIGN, lvalues, res););
                  	cnt++;
                        }
                        /* FIXME: Check that the number of arguments actually matches arg1. */
                        
                    tmp1 = res;
                    goto use_tmp1;
                      }
                    }
                }
              }
            }
          }
        }
      }
    }
  }
  break;

case F_CAST:
  if (!CAR(n)) {
    DBG("Match: ""F_CAST{252}(-{253}, *)""\n");
    DBG("=> ""-{255}""\n");
    goto zap_node;
  } else {
    if (CAR(n)->token == F_CAST) {
      if ((CAR(n)->type == n->type)) {
        DBG("Match: ""0 = F_CAST{259}(1 = F_CAST{260}[CAR(n)->type == n->type], *)""\n");
        DBG("=> ""1 = *{264}""\n");
        goto use_car;
      }
    } else if (CAR(n)->token == F_CONSTANT) {
      if ((CAR(n)->type == n->type)) {
        DBG("Match: ""0 = F_CAST{265}(1 = F_CONSTANT{266}[CAR(n)->type == n->type], *)""\n");
        DBG("=> ""1 = *{270}""\n");
        goto use_car;
      }
    }
    if ((CAR(n)->type == void_type_string)) {
      DBG("Match: ""F_CAST{256}(0 = +{257}[CAR(n)->type == void_type_string], *)""\n");
      {
        yywarning("Casting a void expression\n");
        
        ADD_NODE_REF2(CAR(n),
          tmp1 = CAR(n);
        );
        goto use_tmp1;
      }
    }
  }
  break;

case F_COMMA_EXPR:
  if (!CAR(n)) {
    DBG("Match: ""F_COMMA_EXPR{299}(-{300}, 0 = *{301})""\n");
    DBG("=> ""0 = *{302}""\n");
    goto use_cdr;
  } else if (!CDR(n)) {
    DBG("Match: ""F_COMMA_EXPR{303}(0 = *{304}, -{305})""\n");
    DBG("=> ""0 = *{306}""\n");
    goto use_car;
  } else {
    if (CAR(n)->token == F_ARG_LIST) {
      DBG("Match: ""F_COMMA_EXPR{372}(F_ARG_LIST{373}(0 = *{374}, 1 = *{375}), 2 = *{376})""\n");
      DBG("=> ""F_COMMA_EXPR{377}""\n");
      {
        ADD_NODE_REF2(CAAR(n),
        ADD_NODE_REF2(CDAR(n),
        ADD_NODE_REF2(CDR(n),
          tmp1 = mknode(F_COMMA_EXPR, mknode(F_COMMA_EXPR, CAAR(n), CDAR(n)), CDR(n));
        )));
        goto use_tmp1;
      }
    } else if (CAR(n)->token == F_ASSIGN) {
      if (!CAAR(n)) {
      } else {
        if (CAAR(n)->token == F_LOCAL) {
          if (!CDR(n)) {
          } else {
            if (CDR(n)->token == F_COMMA_EXPR) {
              if (!CADR(n)) {
              } else {
                if (CADR(n)->token == F_DEC) {
                  if (!CDADR(n)) {
                    if (!CAADR(n)) {
                    } else {
                      if (CAADR(n)->token == F_LOCAL) {
                        if ((CAAR(n)->u.integer.a == CAADR(n)->u.integer.a) &&
                            (CAAR(n)->u.integer.b == CAADR(n)->u.integer.b)) {
                          DBG("Match: ""F_COMMA_EXPR{444}(F_ASSIGN{445}(1 = F_LOCAL{446}, 0 = *{447}), F_COMMA_EXPR{448}(F_DEC{449}(F_LOCAL{450}[CAAR(n)->u.integer.a == CAADR(n)->u.integer.a][CAAR(n)->u.integer.b == CAADR(n)->u.integer.b], -{451}), 2 = *{452}))""\n");
                          {
                              struct pike_type *t = CAAR(n)->type;
                              
                            ADD_NODE_REF2(CAAR(n),
                            ADD_NODE_REF2(CDAR(n),
                            ADD_NODE_REF2(CDDR(n),
                              tmp1 = mknode(F_COMMA_EXPR,
                          		mknode(F_ASSIGN, CAAR(n),
                          		       mkefuncallnode("`-",
                          				      mknode(F_ARG_LIST,
                          					     mksoftcastnode(t, CDAR(n)),
                          					     mkintnode(1)))),
                          		CDDR(n));
                            )));
                            goto use_tmp1;
                            }
                        }
                      }
                    }
                  }
                } else if (CADR(n)->token == F_INC) {
                  if (!CAADR(n)) {
                  } else {
                    if (CAADR(n)->token == F_LOCAL) {
                      if ((CAAR(n)->u.integer.a == CAADR(n)->u.integer.a) &&
                          (CAAR(n)->u.integer.b == CAADR(n)->u.integer.b)) {
                        DBG("Match: ""F_COMMA_EXPR{453}(F_ASSIGN{454}(1 = F_LOCAL{455}, 0 = *{456}), F_COMMA_EXPR{457}(F_INC{458}(F_LOCAL{459}[CAAR(n)->u.integer.a == CAADR(n)->u.integer.a][CAAR(n)->u.integer.b == CAADR(n)->u.integer.b], *), 2 = *{461}))""\n");
                        {
                            struct pike_type *t = CAAR(n)->type;
                            
                          ADD_NODE_REF2(CAAR(n),
                          ADD_NODE_REF2(CDAR(n),
                          ADD_NODE_REF2(CDDR(n),
                            tmp1 = mknode(F_COMMA_EXPR,
                        		mknode(F_ASSIGN, CAAR(n),
                        		       mkefuncallnode("`+",
                        				      mknode(F_ARG_LIST,
                        					     mksoftcastnode(t, CDAR(n)),
                        					     mkintnode(1)))),
                        		CDDR(n));
                          )));
                          goto use_tmp1;
                          }
                      }
                    }
                  }
                }
              }
            } else if (CDR(n)->token == F_DEC) {
              if (!CDDR(n)) {
                if (!CADR(n)) {
                } else {
                  if (CADR(n)->token == F_LOCAL) {
                    if (( CAAR(n)->u.integer.a == CADR(n)->u.integer.a ) &&
                        ( CAAR(n)->u.integer.b == CADR(n)->u.integer.b )) {
                      DBG("Match: ""F_COMMA_EXPR{430}(F_ASSIGN{431}(1 = F_LOCAL{432}, 0 = *{433}), F_DEC{434}(F_LOCAL{435}[ CAAR(n)->u.integer.a == CADR(n)->u.integer.a ][ CAAR(n)->u.integer.b == CADR(n)->u.integer.b ], -{436}))""\n");
                      {
                          struct pike_type *t = CAAR(n)->type;
                          
                        ADD_NODE_REF2(CAAR(n),
                        ADD_NODE_REF2(CDAR(n),
                          tmp1 = mknode(F_ASSIGN, CAAR(n),
                      		mkefuncallnode("`-",
                      			       mknode(F_ARG_LIST,
                      				      mksoftcastnode(t, CDAR(n)),
                      				      mkintnode(1))));
                        ));
                        goto use_tmp1;
                        }
                    }
                  }
                }
              }
            } else if (CDR(n)->token == F_INC) {
              if (!CADR(n)) {
              } else {
                if (CADR(n)->token == F_LOCAL) {
                  if (( CAAR(n)->u.integer.a == CADR(n)->u.integer.a ) &&
                      ( CAAR(n)->u.integer.b == CADR(n)->u.integer.b )) {
                    DBG("Match: ""F_COMMA_EXPR{437}(F_ASSIGN{438}(1 = F_LOCAL{439}, 0 = *{440}), F_INC{441}(F_LOCAL{442}[ CAAR(n)->u.integer.a == CADR(n)->u.integer.a ][ CAAR(n)->u.integer.b == CADR(n)->u.integer.b ], *))""\n");
                    {
                        struct pike_type *t = CAAR(n)->type;
                        
                      ADD_NODE_REF2(CAAR(n),
                      ADD_NODE_REF2(CDAR(n),
                        tmp1 = mknode(F_ASSIGN, CAAR(n),
                    		mkefuncallnode("`+",
                    			       mknode(F_ARG_LIST,
                    				      mksoftcastnode(t, CDAR(n)),
                    				      mkintnode(1))));
                      ));
                      goto use_tmp1;
                      }
                  }
                }
              }
            }
          }
        }
        if ((!depend_p(CAAR(n), CAAR(n)))) {
          if (!CDR(n)) {
          } else {
            if (CDR(n)->token == F_COMMA_EXPR) {
              if (!CADR(n)) {
              } else {
                if (CADR(n)->token == F_DEC) {
                  {
                    if (CAADR(n) == CAAR(n)) {
                      if (!CDADR(n)) {
                        DBG("Match: ""F_COMMA_EXPR{414}(F_ASSIGN{415}(1 = +{416}[!depend_p(CAAR(n), CAAR(n))], 0 = *{417}), F_COMMA_EXPR{418}(F_DEC{419}($CAAR(n)$, -{420}), 2 = *{421}))""\n");
                        {
                            struct pike_type *t = CAAR(n)->type;
                            
                          ADD_NODE_REF2(CAAR(n),
                          ADD_NODE_REF2(CDAR(n),
                          ADD_NODE_REF2(CDDR(n),
                            tmp1 = mknode(F_COMMA_EXPR,
                        		mknode(F_ASSIGN, CAAR(n),
                        		       mkefuncallnode("`-",
                        				      mknode(F_ARG_LIST,
                        					     mksoftcastnode(t, CDAR(n)),
                        					     mkintnode(1)))),
                        		CDDR(n));
                          )));
                          goto use_tmp1;
                          }
                      }
                    }
                  }
                } else if (CADR(n)->token == F_INC) {
                  {
                    if (CAADR(n) == CAAR(n)) {
                      DBG("Match: ""F_COMMA_EXPR{422}(F_ASSIGN{423}(1 = +{424}[!depend_p(CAAR(n), CAAR(n))], 0 = *{425}), F_COMMA_EXPR{426}(F_INC{427}($CAAR(n)$, *), 2 = *{429}))""\n");
                      {
                          struct pike_type *t = CAAR(n)->type;
                          
                        ADD_NODE_REF2(CAAR(n),
                        ADD_NODE_REF2(CDAR(n),
                        ADD_NODE_REF2(CDDR(n),
                          tmp1 = mknode(F_COMMA_EXPR,
                      		mknode(F_ASSIGN, CAAR(n),
                      		       mkefuncallnode("`+",
                      				      mknode(F_ARG_LIST,
                      					     mksoftcastnode(t, CDAR(n)),
                      					     mkintnode(1)))),
                      		CDDR(n));
                        )));
                        goto use_tmp1;
                        }
                    }
                  }
                }
              }
            } else if (CDR(n)->token == F_DEC) {
              {
                if (CADR(n) == CAAR(n)) {
                  DBG("Match: ""F_COMMA_EXPR{402}(F_ASSIGN{403}(1 = +{404}[!depend_p(CAAR(n), CAAR(n))], 0 = *{405}), F_DEC{406}($CAAR(n)$, *))""\n");
                  {
                      struct pike_type *t = CAAR(n)->type;
                      
                    ADD_NODE_REF2(CAAR(n),
                    ADD_NODE_REF2(CDAR(n),
                      tmp1 = mknode(F_ASSIGN, CAAR(n),
                  		mkefuncallnode("`-",
                  			       mknode(F_ARG_LIST,
                  				      mksoftcastnode(t, CDAR(n)),
                  				      mkintnode(1))));
                    ));
                    goto use_tmp1;
                    }
                }
              }
            } else if (CDR(n)->token == F_INC) {
              {
                if (CADR(n) == CAAR(n)) {
                  DBG("Match: ""F_COMMA_EXPR{408}(F_ASSIGN{409}(1 = +{410}[!depend_p(CAAR(n), CAAR(n))], 0 = *{411}), F_INC{412}($CAAR(n)$, *))""\n");
                  {
                      struct pike_type *t = CAAR(n)->type;
                      
                    ADD_NODE_REF2(CAAR(n),
                    ADD_NODE_REF2(CDAR(n),
                      tmp1 = mknode(F_ASSIGN, CAAR(n),
                  		mkefuncallnode("`+",
                  			       mknode(F_ARG_LIST,
                  				      mksoftcastnode(t, CDAR(n)),
                  				      mkintnode(1))));
                    ));
                    goto use_tmp1;
                    }
                }
              }
            }
          }
        }
      }
    } else if (CAR(n)->token == F_CAST) {
      if (!CDR(n)) {
      } else {
        DBG("Match: ""F_COMMA_EXPR{359}(F_CAST{360}(0 = *{361}, *), 1 = +{363})""\n");
        DBG("=> ""F_COMMA_EXPR{364}""\n");
        {
          ADD_NODE_REF2(CAAR(n),
          ADD_NODE_REF2(CDR(n),
            tmp1 = mknode(F_COMMA_EXPR, CAAR(n), CDR(n));
          ));
          goto use_tmp1;
        }
      }
    } else if (CAR(n)->token == F_COMMA_EXPR) {
      if (!CDAR(n)) {
      } else {
        if (CDAR(n)->token == F_CONSTANT) {
          if (!CDR(n)) {
          } else {
            if ((CDR(n)->type != void_type_string)) {
              DBG("Match: ""F_COMMA_EXPR{315}(F_COMMA_EXPR{316}(0 = *{317}, F_CONSTANT{318}), 1 = +{319}[CDR(n)->type != void_type_string])""\n");
              DBG("=> ""F_COMMA_EXPR{320}""\n");
              {
                ADD_NODE_REF2(CAAR(n),
                ADD_NODE_REF2(CDR(n),
                  tmp1 = mknode(F_COMMA_EXPR, CAAR(n), CDR(n));
                ));
                goto use_tmp1;
              }
            }
          }
        } else if (CDAR(n)->token == F_POP_VALUE) {
          if (!CDR(n)) {
          } else {
            if (CDR(n)->token == F_POP_VALUE) {
              if (!CADR(n)) {
              } else {
                if ((!(CADR(n)->tree_info & OPT_APPLY))) {
                  DBG("Match: ""F_COMMA_EXPR{343}(F_COMMA_EXPR{344}(0 = *{345}, F_POP_VALUE{346}(1 = *{347}, *)), F_POP_VALUE{349}(2 = +{350}[!(CADR(n)->tree_info & OPT_APPLY)], *))""\n");
                  DBG("=> ""F_COMMA_EXPR{352}""\n");
                  {
                    ADD_NODE_REF2(CAAR(n),
                    ADD_NODE_REF2(CADAR(n),
                    ADD_NODE_REF2(CADR(n),
                      tmp1 = mknode(F_COMMA_EXPR, CAAR(n), mknode(F_POP_VALUE, mknode(F_COMMA_EXPR, CADAR(n), CADR(n)), 0));
                    )));
                    goto use_tmp1;
                  }
                }
              }
            }
          }
        }
        if ((node_is_tossable(CDAR(n)))) {
          if (!CDR(n)) {
          } else {
            if (((CDR(n)->type != void_type_string) ||
                   (CDAR(n)->type == void_type_string))) {
              DBG("Match: ""F_COMMA_EXPR{323}(F_COMMA_EXPR{324}(0 = *{325}, 2 = +{326}[node_is_tossable(CDAR(n))]), 1 = +{327}[(CDR(n)->type != void_type_string) ||\n"
              "                   (CDAR(n)->type == void_type_string)])""\n");
              DBG("=> ""F_COMMA_EXPR{328}""\n");
              {
                ADD_NODE_REF2(CAAR(n),
                ADD_NODE_REF2(CDR(n),
                  tmp1 = mknode(F_COMMA_EXPR, CAAR(n), CDR(n));
                ));
                goto use_tmp1;
              }
            }
          }
        }
      }
    } else if (CAR(n)->token == F_CONSTANT) {
      if (!CDR(n)) {
      } else {
        DBG("Match: ""F_COMMA_EXPR{307}(F_CONSTANT{308}, 0 = +{309})""\n");
        DBG("=> ""0 = *{310}""\n");
        goto use_cdr;
      }
    } else if (CAR(n)->token == F_INITIALIZE) {
      DBG("Match: ""F_COMMA_EXPR{392}(F_INITIALIZE{393}(0 = *{394}, 1 = *{395}), 2 = *{396})""\n");
      DBG("=> ""F_COMMA_EXPR{397}""\n");
      {
        ADD_NODE_REF2(CAAR(n),
        ADD_NODE_REF2(CDAR(n),
        ADD_NODE_REF2(CDR(n),
          tmp1 = mknode(F_COMMA_EXPR, mknode(F_ASSIGN, CAAR(n), CDAR(n)), CDR(n));
        )));
        goto use_tmp1;
      }
    } else if (CAR(n)->token == F_POP_VALUE) {
      if (!CDR(n)) {
      } else {
        if (CDR(n)->token == F_POP_VALUE) {
          if (!CADR(n)) {
          } else {
            if ((!(CADR(n)->tree_info & OPT_APPLY))) {
              DBG("Match: ""F_COMMA_EXPR{331}(F_POP_VALUE{332}(0 = *{333}, *), F_POP_VALUE{335}(1 = +{336}[!(CADR(n)->tree_info & OPT_APPLY)], *))""\n");
              DBG("=> ""F_POP_VALUE{338}""\n");
              {
                ADD_NODE_REF2(CAAR(n),
                ADD_NODE_REF2(CADR(n),
                  tmp1 = mknode(F_POP_VALUE, mknode(F_COMMA_EXPR, CAAR(n), CADR(n)), 0);
                ));
                goto use_tmp1;
              }
            }
          }
        }
      }
    }
    if (CDR(n)->token == F_CAST) {
      DBG("Match: ""F_COMMA_EXPR{367}(0 = *{368}, 1 = F_CAST{369}(2 = *{370}, *))""\n");
      {
        struct pike_type *type = CDR(n)->type;
        
        ADD_NODE_REF2(CADR(n),
        ADD_NODE_REF2(CAR(n),
          tmp1 = mkcastnode(type, mknode(F_COMMA_EXPR, CAR(n), CADR(n)));
        ));
        goto use_tmp1;
      }
    } else if (CDR(n)->token == F_COMMA_EXPR) {
      DBG("Match: ""F_COMMA_EXPR{382}(0 = *{383}, F_COMMA_EXPR{384}(1 = *{385}, 2 = *{386}))""\n");
      DBG("=> ""F_COMMA_EXPR{387}""\n");
      {
        ADD_NODE_REF2(CAR(n),
        ADD_NODE_REF2(CADR(n),
        ADD_NODE_REF2(CDDR(n),
          tmp1 = mknode(F_COMMA_EXPR, mknode(F_COMMA_EXPR, CAR(n), CADR(n)), CDDR(n));
        )));
        goto use_tmp1;
      }
    }
    if ((node_is_tossable(CAR(n)))) {
      if (!CDR(n)) {
      } else {
        if (((CDR(n)->type != void_type_string) ||
                   (CAR(n)->type == void_type_string))) {
          DBG("Match: ""F_COMMA_EXPR{311}(1 = +{312}[node_is_tossable(CAR(n))], 0 = +{313}[(CDR(n)->type != void_type_string) ||\n"
          "                   (CAR(n)->type == void_type_string)])""\n");
          DBG("=> ""0 = *{314}""\n");
          goto use_cdr;
        }
      }
    }
  }
  break;

case F_DEC_LOOP:
  if (!CDR(n)) {
    if (!CAR(n)) {
    } else {
      if (CAR(n)->token == F_VAL_LVAL) {
        if (!CAAR(n)) {
        } else {
          if (( !(CAAR(n)->tree_info & (OPT_SIDE_EFFECT|OPT_ASSIGNMENT|
						OPT_CASE|OPT_CONTINUE|
						OPT_BREAK|OPT_RETURN)) )) {
            if (!CDAR(n)) {
            } else {
              if (( !(CDAR(n)->tree_info & (OPT_SIDE_EFFECT|OPT_ASSIGNMENT|
						OPT_CASE|OPT_CONTINUE|
						OPT_BREAK|OPT_RETURN)) )) {
                DBG("Match: ""F_DEC_LOOP{1387}(F_VAL_LVAL{1388}(0 = +{1389}[ !(CAAR(n)->tree_info & (OPT_SIDE_EFFECT|OPT_ASSIGNMENT|\n"
                "\t\t\t\t\t\tOPT_CASE|OPT_CONTINUE|\n"
                "\t\t\t\t\t\tOPT_BREAK|OPT_RETURN)) ], 1 = +{1390}[ !(CDAR(n)->tree_info & (OPT_SIDE_EFFECT|OPT_ASSIGNMENT|\n"
                "\t\t\t\t\t\tOPT_CASE|OPT_CONTINUE|\n"
                "\t\t\t\t\t\tOPT_BREAK|OPT_RETURN)) ]), -{1391})""\n");
                DBG("=> ""F_POP_VALUE{1392}""\n");
                {
                  ADD_NODE_REF2(CDAR(n),
                  ADD_NODE_REF2(CAAR(n),
                  ADD_NODE_REF2(CDAR(n),
                  ADD_NODE_REF2(CAAR(n),
                    tmp1 = mknode(F_POP_VALUE, mknode('?', mknode(F_GT, mknode(F_DEC, CDAR(n), mkintnode(1)), CAAR(n)), mknode(':', mknode(F_ASSIGN, CDAR(n), CAAR(n)), 0)), 0);
                  ))));
                  goto use_tmp1;
                }
              }
            }
          }
        }
      }
    }
  }
  break;

case F_DIV_EQ:
  if (!CAR(n)) {
  } else {
    DBG("Match: ""F_DIV_EQ{1499}(0 = +{1500}, 1 = *{1501})""\n");
    {
      struct pike_type *type = CAR(n)->type;
      int oper = ((CAR(n)->tree_info&(OPT_SIDE_EFFECT|OPT_ASSIGNMENT)) ||
    	      depend_p(CAR(n), CDR(n))) ? F_ASSIGN_SELF : F_ASSIGN;
      
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CDR(n),
        tmp1 = mknode( oper, CAR(n), mksoftcastnode(type,mkopernode( "`/", CAR(n), CDR(n) )));
      )));
      goto use_tmp1;
    }
  }
  break;

case F_DO:
  if (!CAR(n)) {
    if (!CDR(n)) {
    } else {
      if ((!(CDR(n)->tree_info & (OPT_BREAK|OPT_CONTINUE)))) {
        DBG("Match: ""F_DO{1053}(-{1054}, 0 = +{1055}[!(CDR(n)->tree_info & (OPT_BREAK|OPT_CONTINUE))])""\n");
        DBG("=> ""0 = *{1056}""\n");
        goto use_cdr;
      }
    }
  } else if (!CDR(n)) {
    if (!CAR(n)) {
    } else {
      if ((node_is_true(CAR(n)))) {
        DBG("Match: ""F_DO{1061}(0 = +{1062}[node_is_true(CAR(n))], -{1063})""\n");
        {
          /* Infinite loop */
          
          ADD_NODE_REF2(CAR(n),
            tmp1 = mknode(F_DO, CAR(n), mkefuncallnode("sleep", mkintnode(255)));
          );
          goto use_tmp1;
        }
      }
    }
  } else {
    if ((node_is_false(CAR(n)))) {
      if (!CDR(n)) {
      } else {
        if ((!(CDR(n)->tree_info & (OPT_BREAK|OPT_CONTINUE)))) {
          DBG("Match: ""F_DO{1057}(+{1058}[node_is_false(CAR(n))], 0 = +{1059}[!(CDR(n)->tree_info & (OPT_BREAK|OPT_CONTINUE))])""\n");
          DBG("=> ""0 = *{1060}""\n");
          goto use_cdr;
        }
      }
    }
  }
  break;

case F_FOR:
  if (!CAR(n)) {
    DBG("Match: ""F_FOR{1131}(-{1132}, *)""\n");
    DBG("=> ""-{1134}""\n");
    goto zap_node;
  } else if (!CDR(n)) {
    if (!CAR(n)) {
    } else {
      if (CAR(n)->token == F_DEC) {
        DBG("Match: ""F_FOR{1249}(F_DEC{1250}(0 = *{1251}, *), -{1253})""\n");
        DBG("=> ""F_DEC_NEQ_LOOP{1254}""\n");
        {
          ADD_NODE_REF2(CAAR(n),
            tmp1 = mknode(F_DEC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(0), CAAR(n)), 0);
          );
          goto use_tmp1;
        }
      } else if (CAR(n)->token == F_INC) {
        DBG("Match: ""F_FOR{1153}(F_INC{1154}(0 = *{1155}, *), -{1157})""\n");
        DBG("=> ""F_INC_NEQ_LOOP{1158}""\n");
        {
          ADD_NODE_REF2(CAAR(n),
            tmp1 = mknode(F_INC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(0), CAAR(n)), 0);
          );
          goto use_tmp1;
        }
      } else if (CAR(n)->token == F_POST_DEC) {
        DBG("Match: ""F_FOR{1297}(F_POST_DEC{1298}(0 = *{1299}, *), -{1301})""\n");
        DBG("=> ""F_DEC_NEQ_LOOP{1302}""\n");
        {
          ADD_NODE_REF2(CAAR(n),
            tmp1 = mknode(F_DEC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(-1), CAAR(n)), 0);
          );
          goto use_tmp1;
        }
      } else if (CAR(n)->token == F_POST_INC) {
        DBG("Match: ""F_FOR{1201}(F_POST_INC{1202}(0 = *{1203}, *), -{1205})""\n");
        DBG("=> ""F_INC_NEQ_LOOP{1206}""\n");
        {
          ADD_NODE_REF2(CAAR(n),
            tmp1 = mknode(F_INC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(1), CAAR(n)), 0);
          );
          goto use_tmp1;
        }
      }
      if ((node_is_false(CAR(n)))) {
        DBG("Match: ""F_FOR{1143}(+{1144}[node_is_false(CAR(n))], *)""\n");
        DBG("=> ""-{1146}""\n");
        goto zap_node;
      }
      if ((node_is_tossable(CAR(n)))) {
        DBG("Match: ""F_FOR{1150}(0 = +{1151}[node_is_tossable(CAR(n))], -{1152})""\n");
        {
          /* CPU-wasting delay loop [bug 3907]. */
          
          ADD_NODE_REF2(CAR(n),
            tmp1 = mknode(F_FOR, CAR(n), mknode(':',
        				mkefuncallnode("sleep", mkintnode(1)),
        				0));
          );
          goto use_tmp1;
        }
      }
      if ((node_is_true(CAR(n)))) {
        DBG("Match: ""F_FOR{1147}(0 = +{1148}[node_is_true(CAR(n))], -{1149})""\n");
        {
          /* Infinite loop */
          
          ADD_NODE_REF2(CAR(n),
            tmp1 = mknode(F_FOR, CAR(n), mknode(':',
        				mkefuncallnode("sleep", mkintnode(255)),
        				0));
          );
          goto use_tmp1;
        }
      }
    }
  } else {
    if (CAR(n)->token == F_APPLY) {
      if (!CAAR(n)) {
      } else {
        if (CAAR(n)->token == F_CONSTANT) {
          if ((TYPEOF(CAAR(n)->u.sval) == T_FUNCTION) &&
              (SUBTYPEOF(CAAR(n)->u.sval) == FUNCTION_BUILTIN)) {
            if (!CDR(n)) {
            } else {
              if (CDR(n)->token == ':') {
                DBG("Match: ""F_FOR{1357}(0 = F_APPLY{1358}(1 = F_CONSTANT{1359}[TYPEOF(CAAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAAR(n)->u.sval) == FUNCTION_BUILTIN], 2 = *{1360}), 4 = ':'{1361}(3 = *{1362}, *))""\n");
                {
                  node **last;

                  /* Last is a pointer to the place where the incrementor is in the
                   * tree. This is needed so we can nullify this pointer later and
                   * free the rest of the tree
                   */
                  last = &_CDR(CDR(n));
                  tmp1 = *last;

                  /* We're not interested in casts to void */
                  while(tmp1 &&
                	( (tmp1->token == F_CAST && tmp1->type == void_type_string) ||
                	  tmp1->token == F_POP_VALUE))
                  {
                    last = &_CAR(tmp1);
                    tmp1 = *last;
                  }

                  /* If there is an incrementor, and it is one of x++, ++x, x-- or ++x */
                  if(tmp1 && (tmp1->token == F_INC ||
                	      tmp1->token == F_POST_INC ||
                	      tmp1->token == F_DEC ||
                	      tmp1->token == F_POST_DEC))
                  {
                    node **arg1, **arg2;
                    int oper;
                    int inc;
                    int token;

                    /* does it increment or decrement ? */
                    inc = (tmp1->token==F_INC || tmp1->token==F_POST_INC);

                    /* for(; arg1 oper arg2; z ++) p; */

                    if(CAAR(n)->u.sval.u.efun->function == f_gt)
                      oper = F_GT;
                    else if(CAAR(n)->u.sval.u.efun->function == f_ge)
                      oper = F_GE;
                    else if(CAAR(n)->u.sval.u.efun->function == f_lt)
                      oper = F_LT;
                    else if(CAAR(n)->u.sval.u.efun->function == f_le)
                      oper = F_LE;
                    else if(CAAR(n)->u.sval.u.efun->function == f_ne)
                      oper = F_NE;
                    else
                      goto next_for_opt;

                    if(count_args(CDAR(n)) != 2)
                      goto next_for_opt;

                    arg1 = my_get_arg(&_CDR(CAR(n)), 0);
                    arg2 = my_get_arg(&_CDR(CAR(n)), 1);

                    /* it was not on the form for(; x op y; z++) p; */
                    if(!node_is_eq(*arg1, CAR(tmp1)) || /* x == z */
                       depend_p(*arg2, *arg2) ||	/* does y depend on y? */
                       depend_p(*arg2, *arg1) ||	/* does y depend on x? */
                       depend_p(*arg2, CADR(n)) ||		/* does y depend on p? */
                       depend_p(*arg2, tmp1))		/* does y depend on z? */
                    {
                      /* it was not on the form for(; x op y; z++) p; */
                      if(!node_is_eq(*arg2, CAR(tmp1)) || /* y == z */
                	 depend_p(*arg1, *arg2) ||	/* does x depend on y? */
                	 depend_p(*arg1, *arg1) ||	/* does x depend on x? */
                	 depend_p(*arg1, CADR(n)) ||		/* does x depend on p? */
                	 depend_p(*arg1, tmp1))		/* does x depend on z? */
                      {
                	/* it was not on the form for(; x op y; y++) p; */
                	goto next_for_opt;
                      }else{
                	node **tmparg;
                	/* for(; x op y; y++) p; -> for(; y op^-1 x; y++) p; */

                	switch(oper)
                	{
                	case F_LT: oper = F_GT; break;
                	case F_LE: oper = F_GE; break;
                	case F_GT: oper = F_LT; break;
                	case F_GE: oper = F_LE; break;
                	}

                	tmparg = arg1;
                	arg1 = arg2;
                	arg2 = tmparg;
                      }
                    }

                    if(inc)
                    {
                      if(oper == F_LE) {
                        node *fun;
                        if ( !(fun=find_module_identifier(plus_name, 0)) ) {
                	  yyerror("Internally used efun undefined: `+");
                	  tmp3 = mkintnode(0);
                        } else {
                	  ADD_NODE_REF2(*arg2,
                	    tmp3 = mkapplynode(fun, mknode(F_ARG_LIST, *arg2, mkintnode(1)));
                	  );
                	}
                      } else if(oper == F_LT) {
                	ADD_NODE_REF2(*arg2,
                	  tmp3 = *arg2;
                	);
                      } else
                	goto next_for_opt;
                    }else{
                      if(oper == F_GE) {
                        node *fun;
                        if ( !(fun=find_module_identifier(minus_name, 0)) ) {
                	  yyerror("Internally used efun undefined: `-");
                	  tmp3 = mkintnode(0);
                        } else {
                	  ADD_NODE_REF2(*arg2,
                	    tmp3 = mkapplynode(fun, mknode(F_ARG_LIST, *arg2, mkintnode(1)));
                	  );
                	}
                      } else if(oper == F_GT) {
                	ADD_NODE_REF2(*arg2,
                	  tmp3 = *arg2;
                	);
                      } else
                	goto next_for_opt;
                    }
                    if(oper == F_NE)
                    {
                      if(inc)
                	token = F_INC_NEQ_LOOP;
                      else
                	token = F_DEC_NEQ_LOOP;
                    }else{
                      if(inc)
                	token = F_INC_LOOP;
                      else
                	token = F_DEC_LOOP;
                    }

                    tmp1=CAR(*last);
                    ADD_NODE_REF(CAR(*last));
                    ADD_NODE_REF2(*arg1,
                    ADD_NODE_REF2(CADR(n),
                      tmp2 = mknode(token, mknode(F_VAL_LVAL, tmp3, *arg1), CADR(n));
                    ));

                    tmp1 = mknode(F_COMMA_EXPR, mkcastnode(void_type_string,
                					   mknode(inc ? F_DEC : F_INC, tmp1,
                						  mkintnode(1))), tmp2);
                    goto use_tmp1;
                  }
                 next_for_opt:
                  ;
                }
              }
            }
          }
        }
      }
    } else if (CAR(n)->token == F_DEC) {
      if (!CDR(n)) {
      } else {
        if (CDR(n)->token == ':') {
          if (!CADR(n)) {
            if (!CDDR(n)) {
            } else {
              if ((!(CDDR(n)->tree_info & OPT_CONTINUE))) {
                DBG("Match: ""F_FOR{1259}(F_DEC{1260}(0 = *{1261}, *), ':'{1263}(-{1264}, 1 = +{1265}[!(CDDR(n)->tree_info & OPT_CONTINUE)]))""\n");
                DBG("=> ""F_DEC_NEQ_LOOP{1266}""\n");
                {
                  ADD_NODE_REF2(CAAR(n),
                  ADD_NODE_REF2(CDDR(n),
                    tmp1 = mknode(F_DEC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(0), CAAR(n)), CDDR(n));
                  ));
                  goto use_tmp1;
                }
              }
            }
          } else if (!CDDR(n)) {
            if (!CADR(n)) {
            } else {
              if ((!(CADR(n)->tree_info & OPT_CONTINUE))) {
                DBG("Match: ""F_FOR{1271}(F_DEC{1272}(0 = *{1273}, *), ':'{1275}(1 = +{1276}[!(CADR(n)->tree_info & OPT_CONTINUE)], -{1277}))""\n");
                DBG("=> ""F_DEC_NEQ_LOOP{1278}""\n");
                {
                  ADD_NODE_REF2(CAAR(n),
                  ADD_NODE_REF2(CADR(n),
                    tmp1 = mknode(F_DEC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(0), CAAR(n)), CADR(n));
                  ));
                  goto use_tmp1;
                }
              }
            }
          } else {
            if ((!(CADR(n)->tree_info & OPT_CONTINUE))) {
              if (!CDDR(n)) {
              } else {
                if ((!(CDDR(n)->tree_info & OPT_CONTINUE))) {
                  DBG("Match: ""F_FOR{1283}(F_DEC{1284}(0 = *{1285}, *), ':'{1287}(1 = +{1288}[!(CADR(n)->tree_info & OPT_CONTINUE)], 2 = +{1289}[!(CDDR(n)->tree_info & OPT_CONTINUE)]))""\n");
                  DBG("=> ""F_DEC_NEQ_LOOP{1290}""\n");
                  {
                    ADD_NODE_REF2(CAAR(n),
                    ADD_NODE_REF2(CADR(n),
                    ADD_NODE_REF2(CDDR(n),
                      tmp1 = mknode(F_DEC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(0), CAAR(n)), mknode(F_COMMA_EXPR, CADR(n), CDDR(n)));
                    )));
                    goto use_tmp1;
                  }
                }
              }
            }
          }
        }
      }
    } else if (CAR(n)->token == F_INC) {
      if (!CDR(n)) {
      } else {
        if (CDR(n)->token == ':') {
          if (!CADR(n)) {
            if (!CDDR(n)) {
            } else {
              if ((!(CDDR(n)->tree_info & OPT_CONTINUE))) {
                DBG("Match: ""F_FOR{1163}(F_INC{1164}(0 = *{1165}, *), ':'{1167}(-{1168}, 1 = +{1169}[!(CDDR(n)->tree_info & OPT_CONTINUE)]))""\n");
                DBG("=> ""F_INC_NEQ_LOOP{1170}""\n");
                {
                  ADD_NODE_REF2(CAAR(n),
                  ADD_NODE_REF2(CDDR(n),
                    tmp1 = mknode(F_INC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(0), CAAR(n)), CDDR(n));
                  ));
                  goto use_tmp1;
                }
              }
            }
          } else if (!CDDR(n)) {
            if (!CADR(n)) {
            } else {
              if ((!(CADR(n)->tree_info & OPT_CONTINUE))) {
                DBG("Match: ""F_FOR{1175}(F_INC{1176}(0 = *{1177}, *), ':'{1179}(1 = +{1180}[!(CADR(n)->tree_info & OPT_CONTINUE)], -{1181}))""\n");
                DBG("=> ""F_INC_NEQ_LOOP{1182}""\n");
                {
                  ADD_NODE_REF2(CAAR(n),
                  ADD_NODE_REF2(CADR(n),
                    tmp1 = mknode(F_INC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(0), CAAR(n)), CADR(n));
                  ));
                  goto use_tmp1;
                }
              }
            }
          } else {
            if ((!(CADR(n)->tree_info & OPT_CONTINUE))) {
              if (!CDDR(n)) {
              } else {
                if ((!(CDDR(n)->tree_info & OPT_CONTINUE))) {
                  DBG("Match: ""F_FOR{1187}(F_INC{1188}(0 = *{1189}, *), ':'{1191}(1 = +{1192}[!(CADR(n)->tree_info & OPT_CONTINUE)], 2 = +{1193}[!(CDDR(n)->tree_info & OPT_CONTINUE)]))""\n");
                  DBG("=> ""F_INC_NEQ_LOOP{1194}""\n");
                  {
                    ADD_NODE_REF2(CAAR(n),
                    ADD_NODE_REF2(CADR(n),
                    ADD_NODE_REF2(CDDR(n),
                      tmp1 = mknode(F_INC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(0), CAAR(n)), mknode(F_COMMA_EXPR, CADR(n), CDDR(n)));
                    )));
                    goto use_tmp1;
                  }
                }
              }
            }
          }
        }
      }
    } else if (CAR(n)->token == F_POST_DEC) {
      if (!CDR(n)) {
      } else {
        if (CDR(n)->token == ':') {
          if (!CADR(n)) {
            if (!CDDR(n)) {
            } else {
              if ((!(CDDR(n)->tree_info & OPT_CONTINUE))) {
                DBG("Match: ""F_FOR{1307}(F_POST_DEC{1308}(0 = *{1309}, *), ':'{1311}(-{1312}, 1 = +{1313}[!(CDDR(n)->tree_info & OPT_CONTINUE)]))""\n");
                DBG("=> ""F_DEC_NEQ_LOOP{1314}""\n");
                {
                  ADD_NODE_REF2(CAAR(n),
                  ADD_NODE_REF2(CDDR(n),
                    tmp1 = mknode(F_DEC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(-1), CAAR(n)), CDDR(n));
                  ));
                  goto use_tmp1;
                }
              }
            }
          } else if (!CDDR(n)) {
            if (!CADR(n)) {
            } else {
              if ((!(CADR(n)->tree_info & OPT_CONTINUE))) {
                DBG("Match: ""F_FOR{1319}(F_POST_DEC{1320}(0 = *{1321}, *), ':'{1323}(1 = +{1324}[!(CADR(n)->tree_info & OPT_CONTINUE)], -{1325}))""\n");
                DBG("=> ""F_DEC_NEQ_LOOP{1326}""\n");
                {
                  ADD_NODE_REF2(CAAR(n),
                  ADD_NODE_REF2(CADR(n),
                    tmp1 = mknode(F_DEC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(-1), CAAR(n)), CADR(n));
                  ));
                  goto use_tmp1;
                }
              }
            }
          } else {
            if ((!(CADR(n)->tree_info & OPT_CONTINUE))) {
              if (!CDDR(n)) {
              } else {
                if ((!(CDDR(n)->tree_info & OPT_CONTINUE))) {
                  DBG("Match: ""F_FOR{1331}(F_POST_DEC{1332}(0 = *{1333}, *), ':'{1335}(1 = +{1336}[!(CADR(n)->tree_info & OPT_CONTINUE)], 2 = +{1337}[!(CDDR(n)->tree_info & OPT_CONTINUE)]))""\n");
                  DBG("=> ""F_DEC_NEQ_LOOP{1338}""\n");
                  {
                    ADD_NODE_REF2(CAAR(n),
                    ADD_NODE_REF2(CADR(n),
                    ADD_NODE_REF2(CDDR(n),
                      tmp1 = mknode(F_DEC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(-1), CAAR(n)), mknode(F_COMMA_EXPR, CADR(n), CDDR(n)));
                    )));
                    goto use_tmp1;
                  }
                }
              }
            }
          }
        }
      }
    } else if (CAR(n)->token == F_POST_INC) {
      if (!CDR(n)) {
      } else {
        if (CDR(n)->token == ':') {
          if (!CADR(n)) {
            if (!CDDR(n)) {
            } else {
              if ((!(CDDR(n)->tree_info & OPT_CONTINUE))) {
                DBG("Match: ""F_FOR{1211}(F_POST_INC{1212}(0 = *{1213}, *), ':'{1215}(-{1216}, 1 = +{1217}[!(CDDR(n)->tree_info & OPT_CONTINUE)]))""\n");
                DBG("=> ""F_INC_NEQ_LOOP{1218}""\n");
                {
                  ADD_NODE_REF2(CAAR(n),
                  ADD_NODE_REF2(CDDR(n),
                    tmp1 = mknode(F_INC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(1), CAAR(n)), CDDR(n));
                  ));
                  goto use_tmp1;
                }
              }
            }
          } else if (!CDDR(n)) {
            if (!CADR(n)) {
            } else {
              if ((!(CADR(n)->tree_info & OPT_CONTINUE))) {
                DBG("Match: ""F_FOR{1223}(F_POST_INC{1224}(0 = *{1225}, *), ':'{1227}(1 = +{1228}[!(CADR(n)->tree_info & OPT_CONTINUE)], -{1229}))""\n");
                DBG("=> ""F_INC_NEQ_LOOP{1230}""\n");
                {
                  ADD_NODE_REF2(CAAR(n),
                  ADD_NODE_REF2(CADR(n),
                    tmp1 = mknode(F_INC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(1), CAAR(n)), CADR(n));
                  ));
                  goto use_tmp1;
                }
              }
            }
          } else {
            if ((!(CADR(n)->tree_info & OPT_CONTINUE))) {
              if (!CDDR(n)) {
              } else {
                if ((!(CDDR(n)->tree_info & OPT_CONTINUE))) {
                  DBG("Match: ""F_FOR{1235}(F_POST_INC{1236}(0 = *{1237}, *), ':'{1239}(1 = +{1240}[!(CADR(n)->tree_info & OPT_CONTINUE)], 2 = +{1241}[!(CDDR(n)->tree_info & OPT_CONTINUE)]))""\n");
                  DBG("=> ""F_INC_NEQ_LOOP{1242}""\n");
                  {
                    ADD_NODE_REF2(CAAR(n),
                    ADD_NODE_REF2(CADR(n),
                    ADD_NODE_REF2(CDDR(n),
                      tmp1 = mknode(F_INC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(1), CAAR(n)), mknode(F_COMMA_EXPR, CADR(n), CDDR(n)));
                    )));
                    goto use_tmp1;
                  }
                }
              }
            }
          }
        }
      }
    }
    if (CDR(n)->token == ':') {
      if (!CADR(n)) {
        if (!CDDR(n)) {
          DBG("Match: ""F_FOR{1135}(0 = *{1136}, ':'{1137}(-{1138}, -{1139}))""\n");
          DBG("=> ""F_FOR{1140}""\n");
          {
            ADD_NODE_REF2(CAR(n),
              tmp1 = mknode(F_FOR, CAR(n), 0);
            );
            goto use_tmp1;
          }
        }
      } else if (!CDDR(n)) {
      } else {
        if (CDDR(n)->token == F_CAST) {
          if ((CDDR(n)->type == void_type_string)) {
            DBG("Match: ""F_FOR{1345}(0 = *{1346}, ':'{1347}(1 = *{1348}, F_CAST{1349}[CDDR(n)->type == void_type_string](2 = *{1350}, *)))""\n");
            DBG("=> ""F_FOR{1352}""\n");
            {
              ADD_NODE_REF2(CAR(n),
              ADD_NODE_REF2(CADR(n),
              ADD_NODE_REF2(CADDR(n),
                tmp1 = mknode(F_FOR, CAR(n), mknode(':', CADR(n), CADDR(n)));
              )));
              goto use_tmp1;
            }
          }
        }
      }
    }
    if ((node_is_false(CAR(n)))) {
      DBG("Match: ""F_FOR{1143}(+{1144}[node_is_false(CAR(n))], *)""\n");
      DBG("=> ""-{1146}""\n");
      goto zap_node;
    }
  }
  break;

case F_FOREACH:
  if (!CAR(n)) {
  } else if (!CDR(n)) {
    if (!CAR(n)) {
    } else {
      if (CAR(n)->token == F_FOREACH_VAL_LVAL) {
        if (!CAAR(n)) {
        } else {
          if ((!(CAAR(n)->node_info & (OPT_SIDE_EFFECT|OPT_ASSIGNMENT)))) {
            if (!CDAR(n)) {
            } else {
              if (((CDAR(n)->token != ':'))) {
                DBG("Match: ""F_FOREACH{1064}(F_FOREACH_VAL_LVAL{1065}(0 = +{1066}[!(CAAR(n)->node_info & (OPT_SIDE_EFFECT|OPT_ASSIGNMENT))], 1 = +{1067}[(CDAR(n)->token != ':')]), -{1068})""\n");
                {
                  
                  
                  
                  ADD_NODE_REF2(CAAR(n),
                  ADD_NODE_REF2(CAAR(n),
                  ADD_NODE_REF2(CDAR(n),
                    tmp1 = mknode(F_POP_VALUE,
                	      mknode('?',
                		     mkefuncallnode("sizeof", CAAR(n)),
                		     mknode(':',
                			    mknode(F_ASSIGN, CDAR(n),
                				   mknode(F_INDEX, CAAR(n), mkintnode(-1))),
                			    NULL)),
                	      0);
                  )));
                  goto use_tmp1;
                }
              }
            }
          }
        }
      }
    }
  } else {
    if (CAR(n)->token == F_FOREACH_VAL_LVAL) {
      if (!CAAR(n)) {
      } else if (!CDAR(n)) {
        DBG("Match: ""F_FOREACH{1087}(F_FOREACH_VAL_LVAL{1088}(0 = *{1089}, -{1090}), 1 = *{1091})""\n");
        {
            
          ADD_NODE_REF2(CAAR(n),
          ADD_NODE_REF2(CDR(n),
            tmp1 = mknode(F_LOOP, mkefuncallnode("sizeof", CAAR(n)), CDR(n));
          ));
          goto use_tmp1;
          }
      } else {
        if (CAAR(n)->token == F_APPLY) {
          if (!CAAAR(n)) {
          } else {
            if (CAAAR(n)->token == F_CONSTANT) {
              if ((TYPEOF(CAAAR(n)->u.sval) == T_FUNCTION) &&
                  (SUBTYPEOF(CAAAR(n)->u.sval) == FUNCTION_BUILTIN) &&
                  (CAAAR(n)->u.sval.u.efun->function == f_divide)) {
                if (!CDAAR(n)) {
                } else {
                  if (CDAAR(n)->token == F_ARG_LIST) {
                    if (!CADAAR(n)) {
                    } else {
                      if ((pike_types_le(CADAAR(n)->type, string_type_string, 0, 0))) {
                        if (!CDDAAR(n)) {
                        } else {
                          if (CDDAAR(n)->token == F_CONSTANT) {
                            if ((TYPEOF(CDDAAR(n)->u.sval) == T_STRING) &&
                                (CDDAAR(n)->u.sval.u.string->len == 1)) {
                              DBG("Match: ""F_FOREACH{1092}(F_FOREACH_VAL_LVAL{1093}(F_APPLY{1094}(F_CONSTANT{1095}[TYPEOF(CAAAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAAAR(n)->u.sval) == FUNCTION_BUILTIN][CAAAR(n)->u.sval.u.efun->function == f_divide], F_ARG_LIST{1096}(0 = +{1097}[pike_types_le(CADAAR(n)->type, string_type_string, 0, 0)], 1 = F_CONSTANT{1098}[TYPEOF(CDDAAR(n)->u.sval) == T_STRING][CDDAAR(n)->u.sval.u.string->len == 1])), 2 = *{1099}), 3 = *{1100})""\n");
                              {
                                extern struct program *string_split_iterator_program;
                                node *vars;
                                p_wchar2 split = index_shared_string(CDDAAR(n)->u.sval.u.string, 0);
                                struct pike_type *t = CADAAR(n)->type;

                                ADD_NODE_REF2(CDAR(n),
                                  if (CDAR(n)->token == ':') {
                                    vars = CDAR(n);
                                  } else {
                                    /* Old-style. Convert to new-style. */
                                    vars = mknode(':', NULL, CDAR(n));
                                  }
                                );

                                
                                ADD_NODE_REF2(CADAAR(n),
                                ADD_NODE_REF2(CDR(n),
                                  tmp1 = mknode(F_FOREACH,
                              	      mknode(F_FOREACH_VAL_LVAL,
                                                   mkapplynode(mkbindnode(
                                                                 mkprgnode(string_split_iterator_program), t),
                              				 mknode(F_ARG_LIST, CADAAR(n),
                              					mkintnode(split))),
                              		     vars),
                              	      CDR(n));
                                ));
                                goto use_tmp1;
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
              if ((TYPEOF(CAAAR(n)->u.sval) == T_FUNCTION) &&
                  (SUBTYPEOF(CAAAR(n)->u.sval) == FUNCTION_BUILTIN) &&
                  (CAAAR(n)->u.sval.u.efun->function == f_minus)) {
                if (!CDAAR(n)) {
                } else {
                  if (CDAAR(n)->token == F_ARG_LIST) {
                    if (!CADAAR(n)) {
                    } else {
                      if (CADAAR(n)->token == F_APPLY) {
                        if (!CAADAAR(n)) {
                        } else {
                          if (CAADAAR(n)->token == F_CONSTANT) {
                            if ((TYPEOF(CAADAAR(n)->u.sval) == T_FUNCTION) &&
                                (SUBTYPEOF(CAADAAR(n)->u.sval) == FUNCTION_BUILTIN) &&
                                (CAADAAR(n)->u.sval.u.efun->function == f_divide)) {
                              if (!CDADAAR(n)) {
                              } else {
                                if (CDADAAR(n)->token == F_ARG_LIST) {
                                  if (!CADADAAR(n)) {
                                  } else {
                                    if ((pike_types_le(CADADAAR(n)->type, string_type_string, 0, 0))) {
                                      if (!CDDADAAR(n)) {
                                      } else {
                                        if (CDDADAAR(n)->token == F_CONSTANT) {
                                          if ((TYPEOF(CDDADAAR(n)->u.sval) == T_STRING) &&
                                              (CDDADAAR(n)->u.sval.u.string->len == 1)) {
                                            if (!CDDAAR(n)) {
                                            } else {
                                              if (CDDAAR(n)->token == F_APPLY) {
                                                if (!CADDAAR(n)) {
                                                } else {
                                                  if (CADDAAR(n)->token == F_CONSTANT) {
                                                    if ((TYPEOF(CADDAAR(n)->u.sval) == T_FUNCTION) &&
                                                        (SUBTYPEOF(CADDAAR(n)->u.sval) == FUNCTION_BUILTIN) &&
                                                        (CADDAAR(n)->u.sval.u.efun->function == f_allocate)) {
                                                      if (!CDDDAAR(n)) {
                                                      } else {
                                                        if (CDDDAAR(n)->token == F_ARG_LIST) {
                                                          if (!CADDDAAR(n)) {
                                                          } else {
                                                            if (CADDDAAR(n)->token == F_CONSTANT) {
                                                              if ((TYPEOF(CADDDAAR(n)->u.sval) == T_INT) &&
                                                                  (CADDDAAR(n)->u.sval.u.integer == 1)) {
                                                                if (!CDDDDAAR(n)) {
                                                                } else {
                                                                  if (CDDDDAAR(n)->token == F_CONSTANT) {
                                                                    if ((TYPEOF(CDDDDAAR(n)->u.sval) == T_STRING) &&
                                                                        (CDDDDAAR(n)->u.sval.u.string->len == 0)) {
                                                                      DBG("Match: ""F_FOREACH{1114}(F_FOREACH_VAL_LVAL{1115}(F_APPLY{1116}(F_CONSTANT{1117}[TYPEOF(CAAAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAAAR(n)->u.sval) == FUNCTION_BUILTIN][CAAAR(n)->u.sval.u.efun->function == f_minus], F_ARG_LIST{1118}(F_APPLY{1119}(F_CONSTANT{1120}[TYPEOF(CAADAAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAADAAR(n)->u.sval) == FUNCTION_BUILTIN][CAADAAR(n)->u.sval.u.efun->function == f_divide], F_ARG_LIST{1121}(0 = +{1122}[pike_types_le(CADADAAR(n)->type, string_type_string, 0, 0)], 1 = F_CONSTANT{1123}[TYPEOF(CDDADAAR(n)->u.sval) == T_STRING][CDDADAAR(n)->u.sval.u.string->len == 1])), F_APPLY{1124}(F_CONSTANT{1125}[TYPEOF(CADDAAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CADDAAR(n)->u.sval) == FUNCTION_BUILTIN][CADDAAR(n)->u.sval.u.efun->function == f_allocate], F_ARG_LIST{1126}(F_CONSTANT{1127}[TYPEOF(CADDDAAR(n)->u.sval) == T_INT][CADDDAAR(n)->u.sval.u.integer == 1], F_CONSTANT{1128}[TYPEOF(CDDDDAAR(n)->u.sval) == T_STRING][CDDDDAAR(n)->u.sval.u.string->len == 0])))), 2 = *{1129}), 3 = *{1130})""\n");
                                                                      {
                                                                        extern struct program *string_split_iterator_program;
                                                                        node *vars;
                                                                        p_wchar2 split = index_shared_string(CDDADAAR(n)->u.sval.u.string, 0);
                                                                        struct pike_type *t = CADADAAR(n)->type;

                                                                        ADD_NODE_REF2(CDAR(n),
                                                                          if (CDAR(n)->token == ':') {
                                                                            vars = CDAR(n);
                                                                          } else {
                                                                            /* Old-style. Convert to new-style. */
                                                                            vars = mknode(':', NULL, CDAR(n));
                                                                          }
                                                                        );

                                                                        
                                                                        ADD_NODE_REF2(CADADAAR(n),
                                                                        ADD_NODE_REF2(CDR(n),
                                                                          tmp1 = mknode(F_FOREACH,
                                                                      	      mknode(F_FOREACH_VAL_LVAL,
                                                                                           mkapplynode(mkbindnode(
                                                                                                         mkprgnode(string_split_iterator_program), t),
                                                                      				 mknestednodes(F_ARG_LIST, CADADAAR(n),
                                                                      					       mkintnode(split),
                                                                      					       mkintnode(1),
                                                                      					       NULL)),
                                                                      		     vars),
                                                                      	      CDR(n));
                                                                        ));
                                                                        goto use_tmp1;
                                                                      }
                                                                    }
                                                                  }
                                                                }
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              } else if (CDDAAR(n)->token == F_CONSTANT) {
                                                if ((TYPEOF(CDDAAR(n)->u.sval) == T_ARRAY) &&
                                                    (CDDAAR(n)->u.sval.u.array->size == 1) &&
                                                    (TYPEOF(CDDAAR(n)->u.sval.u.array->item[0]) == T_STRING) &&
                                                    (CDDAAR(n)->u.sval.u.array->item[0].u.string->len == 0)) {
                                                  DBG("Match: ""F_FOREACH{1101}(F_FOREACH_VAL_LVAL{1102}(F_APPLY{1103}(F_CONSTANT{1104}[TYPEOF(CAAAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAAAR(n)->u.sval) == FUNCTION_BUILTIN][CAAAR(n)->u.sval.u.efun->function == f_minus], F_ARG_LIST{1105}(F_APPLY{1106}(F_CONSTANT{1107}[TYPEOF(CAADAAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAADAAR(n)->u.sval) == FUNCTION_BUILTIN][CAADAAR(n)->u.sval.u.efun->function == f_divide], F_ARG_LIST{1108}(0 = +{1109}[pike_types_le(CADADAAR(n)->type, string_type_string, 0, 0)], 1 = F_CONSTANT{1110}[TYPEOF(CDDADAAR(n)->u.sval) == T_STRING][CDDADAAR(n)->u.sval.u.string->len == 1])), F_CONSTANT{1111}[TYPEOF(CDDAAR(n)->u.sval) == T_ARRAY][CDDAAR(n)->u.sval.u.array->size == 1][TYPEOF(CDDAAR(n)->u.sval.u.array->item[0]) == T_STRING][CDDAAR(n)->u.sval.u.array->item[0].u.string->len == 0])), 2 = *{1112}), 3 = *{1113})""\n");
                                                  {
                                                    extern struct program *string_split_iterator_program;
                                                    node *vars;
                                                    p_wchar2 split = index_shared_string(CDDADAAR(n)->u.sval.u.string, 0);
                                                    struct pike_type *t = CADADAAR(n)->type;

                                                    ADD_NODE_REF2(CDAR(n),
                                                      if (CDAR(n)->token == ':') {
                                                        vars = CDAR(n);
                                                      } else {
                                                        /* Old-style. Convert to new-style. */
                                                        vars = mknode(':', NULL, CDAR(n));
                                                      }
                                                    );

                                                    
                                                    ADD_NODE_REF2(CADADAAR(n),
                                                    ADD_NODE_REF2(CDR(n),
                                                      tmp1 = mknode(F_FOREACH,
                                                  	      mknode(F_FOREACH_VAL_LVAL,
                                                                       mkapplynode(mkbindnode(
                                                                                     mkprgnode(string_split_iterator_program), t),
                                                  				 mknestednodes(F_ARG_LIST,
                                                  					       CADADAAR(n),
                                                  					       mkintnode(split),
                                                  					       mkintnode(1),
                                                  					       NULL)),
                                                  		     vars),
                                                  	      CDR(n));
                                                    ));
                                                    goto use_tmp1;
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
        if (( pike_types_le(CAAR(n)->type, array_type_string, 0, 0) )) {
          if (!CDAR(n)) {
          } else {
            if (CDAR(n)->token == ':') {
              if (!CADAR(n)) {
                DBG("Match: ""F_FOREACH{1075}(F_FOREACH_VAL_LVAL{1076}(0 = +{1077}[ pike_types_le(CAAR(n)->type, array_type_string, 0, 0) ], ':'{1078}(-{1079}, 1 = *{1080})), 2 = *{1081})""\n");
                DBG("=> ""F_FOREACH{1082}""\n");
                {
                  ADD_NODE_REF2(CAAR(n),
                  ADD_NODE_REF2(CDDAR(n),
                  ADD_NODE_REF2(CDR(n),
                    tmp1 = mknode(F_FOREACH, mknode(F_FOREACH_VAL_LVAL, CAAR(n), CDDAR(n)), CDR(n));
                  )));
                  goto use_tmp1;
                }
              }
            }
          }
        }
      }
    }
  }
  break;

case F_INC_LOOP:
  if (!CAR(n)) {
  } else if (!CDR(n)) {
    if (!CAR(n)) {
    } else {
      if (CAR(n)->token == F_VAL_LVAL) {
        if (!CAAR(n)) {
        } else {
          if (( !(CAAR(n)->tree_info & (OPT_SIDE_EFFECT|OPT_ASSIGNMENT|
						OPT_CASE|OPT_CONTINUE|
						OPT_BREAK|OPT_RETURN)) )) {
            if (!CDAR(n)) {
            } else {
              if (( !(CDAR(n)->tree_info & (OPT_SIDE_EFFECT|OPT_ASSIGNMENT|
						OPT_CASE|OPT_CONTINUE|
						OPT_BREAK|OPT_RETURN)) )) {
                DBG("Match: ""F_INC_LOOP{1369}(F_VAL_LVAL{1370}(0 = +{1371}[ !(CAAR(n)->tree_info & (OPT_SIDE_EFFECT|OPT_ASSIGNMENT|\n"
                "\t\t\t\t\t\tOPT_CASE|OPT_CONTINUE|\n"
                "\t\t\t\t\t\tOPT_BREAK|OPT_RETURN)) ], 1 = +{1372}[ !(CDAR(n)->tree_info & (OPT_SIDE_EFFECT|OPT_ASSIGNMENT|\n"
                "\t\t\t\t\t\tOPT_CASE|OPT_CONTINUE|\n"
                "\t\t\t\t\t\tOPT_BREAK|OPT_RETURN)) ]), -{1373})""\n");
                DBG("=> ""F_POP_VALUE{1374}""\n");
                {
                  ADD_NODE_REF2(CDAR(n),
                  ADD_NODE_REF2(CAAR(n),
                  ADD_NODE_REF2(CDAR(n),
                  ADD_NODE_REF2(CAAR(n),
                    tmp1 = mknode(F_POP_VALUE, mknode('?', mknode(F_LT, mknode(F_INC, CDAR(n), mkintnode(1)), CAAR(n)), mknode(':', mknode(F_ASSIGN, CDAR(n), CAAR(n)), 0)), 0);
                  ))));
                  goto use_tmp1;
                }
              }
            }
          }
        }
      }
    }
  } else {
    if (CAR(n)->token == F_VAL_LVAL) {
      if (!CAAR(n)) {
      } else {
        if (( !(CAAR(n)->tree_info & (OPT_SIDE_EFFECT|OPT_ASSIGNMENT|
						OPT_CASE|OPT_CONTINUE|
						OPT_BREAK|OPT_RETURN)) )) {
          if (!CDAR(n)) {
          } else {
            if (( !(CDAR(n)->tree_info & (OPT_SIDE_EFFECT|OPT_ASSIGNMENT|
						OPT_CASE|OPT_CONTINUE|
						OPT_BREAK|OPT_RETURN)) )) {
              if (!CDR(n)) {
              } else {
                if (( !(CDR(n)->tree_info & (OPT_BREAK|OPT_CONTINUE)) ) &&
                    ( !depend2_p(CDR(n), CDAR(n)) )) {
                  DBG("Match: ""F_INC_LOOP{1364}(F_VAL_LVAL{1365}(0 = +{1366}[ !(CAAR(n)->tree_info & (OPT_SIDE_EFFECT|OPT_ASSIGNMENT|\n"
                  "\t\t\t\t\t\tOPT_CASE|OPT_CONTINUE|\n"
                  "\t\t\t\t\t\tOPT_BREAK|OPT_RETURN)) ], 1 = +{1367}[ !(CDAR(n)->tree_info & (OPT_SIDE_EFFECT|OPT_ASSIGNMENT|\n"
                  "\t\t\t\t\t\tOPT_CASE|OPT_CONTINUE|\n"
                  "\t\t\t\t\t\tOPT_BREAK|OPT_RETURN)) ]), 2 = +{1368}[ !(CDR(n)->tree_info & (OPT_BREAK|OPT_CONTINUE)) ][ !depend2_p(CDR(n), CDAR(n)) ])""\n");
                  {
                      
                    ADD_NODE_REF2(CAAR(n),
                    ADD_NODE_REF2(CAAR(n),
                    ADD_NODE_REF2(CDAR(n),
                    ADD_NODE_REF2(CDAR(n),
                    ADD_NODE_REF2(CDR(n),
                      tmp1 = mknode(F_COMMA_EXPR,
                  		mknode(F_LOOP,
                  		       mkefuncallnode("`+",
                  				      mknode(F_ARG_LIST,
                  					     mkefuncallnode("`-", CDAR(n)),
                  					     mknode(F_ARG_LIST,
                  						    mkintnode(-1),
                  						    CAAR(n)))), CDR(n)),
                  		mkcastnode(void_type_string, mknode(F_ASSIGN, CDAR(n), CAAR(n))));
                    )))));
                    goto use_tmp1;
                    }
                }
              }
            }
          }
        }
      }
    }
  }
  break;

case F_INDEX:
  if (!CAR(n)) {
    DBG("Match: ""F_INDEX{1028}(-{1029}, *)""\n");
    DBG("=> ""F_COMMA_EXPR{1031}""\n");
    {
      ADD_NODE_REF2(CDR(n),
        tmp1 = mknode(F_COMMA_EXPR, mknode(F_POP_VALUE, CDR(n), 0), mkintnode(0));
      );
      goto use_tmp1;
    }
  } else {
    if (( !match_types(CAR(n)->type, object_type_string) )) {
      if (!CDR(n)) {
      } else {
        if (CDR(n)->token == F_CONSTANT) {
          if ((TYPEOF(CDR(n)->u.sval) == T_STRING)) {
            DBG("Match: ""F_INDEX{1036}(0 = +{1037}[ !match_types(CAR(n)->type, object_type_string) ], 1 = F_CONSTANT{1038}[TYPEOF(CDR(n)->u.sval) == T_STRING])""\n");
            DBG("=> ""F_ARROW{1039}""\n");
            {
              ADD_NODE_REF2(CAR(n),
              ADD_NODE_REF2(CDR(n),
                tmp1 = mknode(F_ARROW, CAR(n), CDR(n));
              ));
              goto use_tmp1;
            }
          }
        }
      }
    }
  }
  break;

case F_LAND:
  if (!CAR(n)) {
    DBG("Match: ""F_LAND{663}(-{664}, 0 = *{665})""\n");
    DBG("=> ""-{666}""\n");
    goto zap_node;
  } else if (!CDR(n)) {
    if (!CAR(n)) {
    } else {
      if ((node_is_false(CAR(n)))) {
        DBG("Match: ""F_LAND{739}(0 = +{740}[node_is_false(CAR(n))], *)""\n");
        DBG("=> ""0 = *{742}""\n");
        goto use_car;
      }
      if ((node_is_true(CAR(n)))) {
        DBG("Match: ""F_LAND{735}(+{736}[node_is_true(CAR(n))], 0 = *{737})""\n");
        DBG("=> ""0 = *{738}""\n");
        goto use_cdr;
      }
    }
    DBG("Match: ""F_LAND{667}(0 = *{668}, -{669})""\n");
    DBG("=> ""F_COMMA_EXPR{670}""\n");
    {
      ADD_NODE_REF2(CAR(n),
        tmp1 = mknode(F_COMMA_EXPR, CAR(n), mkintnode(0));
      );
      goto use_tmp1;
    }
  } else {
    if (CAR(n)->token == F_APPLY) {
      if (!CAAR(n)) {
      } else {
        if (CAAR(n)->token == F_CONSTANT) {
          if ((TYPEOF(CAAR(n)->u.sval) == T_FUNCTION) &&
              (SUBTYPEOF(CAAR(n)->u.sval) == FUNCTION_BUILTIN) &&
              (CAAR(n)->u.sval.u.efun->function == f_not)) {
            if (!CDR(n)) {
            } else {
              if (CDR(n)->token == F_APPLY) {
                if (!CADR(n)) {
                } else {
                  if (CADR(n)->token == F_CONSTANT) {
                    if ((TYPEOF(CADR(n)->u.sval) == T_FUNCTION) &&
                        (SUBTYPEOF(CADR(n)->u.sval) == FUNCTION_BUILTIN) &&
                        (CADR(n)->u.sval.u.efun->function == f_not)) {
                      DBG("Match: ""F_LAND{673}(F_APPLY{674}(0 = F_CONSTANT{675}[TYPEOF(CAAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAAR(n)->u.sval) == FUNCTION_BUILTIN][CAAR(n)->u.sval.u.efun->function == f_not], 1 = *{676}), F_APPLY{677}(F_CONSTANT{678}[TYPEOF(CADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CADR(n)->u.sval) == FUNCTION_BUILTIN][CADR(n)->u.sval.u.efun->function == f_not], 2 = *{679}))""\n");
                      DBG("=> ""F_APPLY{680}""\n");
                      {
                        ADD_NODE_REF2(CAAR(n),
                        ADD_NODE_REF2(CDAR(n),
                        ADD_NODE_REF2(CDDR(n),
                          tmp1 = mknode(F_APPLY, CAAR(n), mknode(F_LOR, CDAR(n), CDDR(n)));
                        )));
                        goto use_tmp1;
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    } else if (CAR(n)->token == F_ASSIGN) {
      if (!CDAR(n)) {
      } else {
        if ((node_is_false(CDAR(n)))) {
          DBG("Match: ""F_LAND{713}(0 = F_ASSIGN{714}(*, +{716}[node_is_false(CDAR(n))]), *)""\n");
          DBG("=> ""0 = *{718}""\n");
          goto use_car;
        }
        if ((node_is_true(CDAR(n)))) {
          DBG("Match: ""F_LAND{695}(0 = F_ASSIGN{696}(*, +{698}[node_is_true(CDAR(n))]), 2 = *{699})""\n");
          DBG("=> ""F_COMMA_EXPR{700}""\n");
          {
            ADD_NODE_REF2(CAR(n),
            ADD_NODE_REF2(CDR(n),
              tmp1 = mknode(F_COMMA_EXPR, mknode(F_POP_VALUE, CAR(n), 0), CDR(n));
            ));
            goto use_tmp1;
          }
        }
      }
    } else if (CAR(n)->token == F_COMMA_EXPR) {
      if (!CDAR(n)) {
      } else {
        if ((CDAR(n)->token != F_POP_VALUE)) {
          DBG("Match: ""F_LAND{725}(F_COMMA_EXPR{726}(0 = *{727}, 1 = +{728}[CDAR(n)->token != F_POP_VALUE]), 2 = *{729})""\n");
          DBG("=> ""F_COMMA_EXPR{730}""\n");
          {
            ADD_NODE_REF2(CAAR(n),
            ADD_NODE_REF2(CDAR(n),
            ADD_NODE_REF2(CDR(n),
              tmp1 = mknode(F_COMMA_EXPR, CAAR(n), mknode(F_LAND, CDAR(n), CDR(n)));
            )));
            goto use_tmp1;
          }
        }
      }
    } else if (CAR(n)->token == F_INITIALIZE) {
      if (!CDAR(n)) {
      } else {
        if ((node_is_false(CDAR(n)))) {
          DBG("Match: ""F_LAND{719}(0 = F_INITIALIZE{720}(*, +{722}[node_is_false(CDAR(n))]), *)""\n");
          DBG("=> ""0 = *{724}""\n");
          goto use_car;
        }
        if ((node_is_true(CDAR(n)))) {
          DBG("Match: ""F_LAND{705}(0 = F_INITIALIZE{706}(*, +{708}[node_is_true(CDAR(n))]), 2 = *{709})""\n");
          DBG("=> ""F_COMMA_EXPR{710}""\n");
          {
            ADD_NODE_REF2(CAR(n),
            ADD_NODE_REF2(CDR(n),
              tmp1 = mknode(F_COMMA_EXPR, CAR(n), CDR(n));
            ));
            goto use_tmp1;
          }
        }
      }
    } else if (CAR(n)->token == F_LAND) {
      if (!CDAR(n)) {
      } else {
        if ((node_is_false(CDAR(n)))) {
          DBG("Match: ""F_LAND{743}(0 = F_LAND{744}(*, +{746}[node_is_false(CDAR(n))]), *)""\n");
          DBG("=> ""0 = *{748}""\n");
          goto use_car;
        }
      }
    }
    if (CDR(n)->token == F_LAND) {
      DBG("Match: ""F_LAND{685}(0 = *{686}, F_LAND{687}(1 = *{688}, 2 = *{689}))""\n");
      DBG("=> ""F_LAND{690}""\n");
      {
        ADD_NODE_REF2(CAR(n),
        ADD_NODE_REF2(CADR(n),
        ADD_NODE_REF2(CDDR(n),
          tmp1 = mknode(F_LAND, mknode(F_LAND, CAR(n), CADR(n)), CDDR(n));
        )));
        goto use_tmp1;
      }
    }
    if ((node_is_false(CAR(n)))) {
      DBG("Match: ""F_LAND{739}(0 = +{740}[node_is_false(CAR(n))], *)""\n");
      DBG("=> ""0 = *{742}""\n");
      goto use_car;
    }
    if ((node_is_true(CAR(n)))) {
      DBG("Match: ""F_LAND{735}(+{736}[node_is_true(CAR(n))], 0 = *{737})""\n");
      DBG("=> ""0 = *{738}""\n");
      goto use_cdr;
    }
  }
  break;

case F_LOOP:
  if (!CAR(n)) {
  } else if (!CDR(n)) {
    DBG("Match: ""F_LOOP{1069}(0 = *{1070}, -{1071})""\n");
    DBG("=> ""F_POP_VALUE{1072}""\n");
    {
      ADD_NODE_REF2(CAR(n),
        tmp1 = mknode(F_POP_VALUE, CAR(n), 0);
      );
      goto use_tmp1;
    }
  } else {
    if (CDR(n)->token == F_POP_VALUE) {
      if (!CDDR(n)) {
        DBG("Match: ""F_LOOP{1405}(0 = *{1406}, F_POP_VALUE{1407}(1 = *{1408}, -{1409}))""\n");
        DBG("=> ""F_LOOP{1410}""\n");
        {
          ADD_NODE_REF2(CAR(n),
          ADD_NODE_REF2(CADR(n),
            tmp1 = mknode(F_LOOP, CAR(n), CADR(n));
          ));
          goto use_tmp1;
        }
      }
    }
    if (( !depend_p(CAR(n), CAR(n)) )) {
      if (!CDR(n)) {
      } else {
        if (CDR(n)->token == F_DEC) {
          if (( pike_types_le(CDR(n)->type, int_type_string, 0, 0) )) {
            if (!CADR(n)) {
            } else {
              if (( !depend_p(CADR(n), CADR(n)) )) {
                DBG("Match: ""F_LOOP{1433}(0 = +{1434}[ !depend_p(CAR(n), CAR(n)) ], F_DEC{1435}[ pike_types_le(CDR(n)->type, int_type_string, 0, 0) ](1 = +{1436}[ !depend_p(CADR(n), CADR(n)) ], *))""\n");
                DBG("=> ""F_POP_VALUE{1438}""\n");
                {
                  ADD_NODE_REF2(CADR(n),
                  ADD_NODE_REF2(CAR(n),
                    tmp1 = mknode(F_POP_VALUE, mknode(F_SUB_EQ, CADR(n), CAR(n)), 0);
                  ));
                  goto use_tmp1;
                }
              }
            }
          }
        } else if (CDR(n)->token == F_INC) {
          if (( pike_types_le(CDR(n)->type, int_type_string, 0, 0) )) {
            if (!CADR(n)) {
            } else {
              if (( !depend_p(CADR(n), CADR(n)) )) {
                DBG("Match: ""F_LOOP{1413}(0 = +{1414}[ !depend_p(CAR(n), CAR(n)) ], F_INC{1415}[ pike_types_le(CDR(n)->type, int_type_string, 0, 0) ](1 = +{1416}[ !depend_p(CADR(n), CADR(n)) ], *))""\n");
                DBG("=> ""F_POP_VALUE{1418}""\n");
                {
                  ADD_NODE_REF2(CADR(n),
                  ADD_NODE_REF2(CAR(n),
                    tmp1 = mknode(F_POP_VALUE, mknode(F_ADD_EQ, CADR(n), CAR(n)), 0);
                  ));
                  goto use_tmp1;
                }
              }
            }
          }
        } else if (CDR(n)->token == F_POST_DEC) {
          if (( pike_types_le(CDR(n)->type, int_type_string, 0, 0) )) {
            if (!CADR(n)) {
            } else {
              if (( !depend_p(CADR(n), CADR(n)) )) {
                DBG("Match: ""F_LOOP{1443}(0 = +{1444}[ !depend_p(CAR(n), CAR(n)) ], F_POST_DEC{1445}[ pike_types_le(CDR(n)->type, int_type_string, 0, 0) ](1 = +{1446}[ !depend_p(CADR(n), CADR(n)) ], *))""\n");
                DBG("=> ""F_POP_VALUE{1448}""\n");
                {
                  ADD_NODE_REF2(CADR(n),
                  ADD_NODE_REF2(CAR(n),
                    tmp1 = mknode(F_POP_VALUE, mknode(F_SUB_EQ, CADR(n), CAR(n)), 0);
                  ));
                  goto use_tmp1;
                }
              }
            }
          }
        } else if (CDR(n)->token == F_POST_INC) {
          if (( pike_types_le(CDR(n)->type, int_type_string, 0, 0) )) {
            if (!CADR(n)) {
            } else {
              if (( !depend_p(CADR(n), CADR(n)) )) {
                DBG("Match: ""F_LOOP{1423}(0 = +{1424}[ !depend_p(CAR(n), CAR(n)) ], F_POST_INC{1425}[ pike_types_le(CDR(n)->type, int_type_string, 0, 0) ](1 = +{1426}[ !depend_p(CADR(n), CADR(n)) ], *))""\n");
                DBG("=> ""F_POP_VALUE{1428}""\n");
                {
                  ADD_NODE_REF2(CADR(n),
                  ADD_NODE_REF2(CAR(n),
                    tmp1 = mknode(F_POP_VALUE, mknode(F_ADD_EQ, CADR(n), CAR(n)), 0);
                  ));
                  goto use_tmp1;
                }
              }
            }
          }
        }
      }
    }
    if (( !depend_p(CAR(n), CAR(n))) &&
        ( !(CAR(n)->tree_info & (OPT_SIDE_EFFECT|OPT_ASSIGNMENT|
			    OPT_CASE|OPT_CONTINUE|
			    OPT_BREAK|OPT_RETURN)) )) {
      if (!CDR(n)) {
      } else {
        if (CDR(n)->token == F_ADD_EQ) {
          if (!CADR(n)) {
          } else {
            if (( !depend_p(CADR(n), CADR(n)) )) {
              if (!CDDR(n)) {
              } else {
                if (( !depend_p(CDDR(n), CADR(n)) ) &&
                    ( !depend_p(CDDR(n), CDDR(n)) ) &&
                    ( !(CDDR(n)->tree_info & OPT_SIDE_EFFECT) ) &&
                    ( (((CDDR(n)->type == int_type_string) &&
		    (CADR(n)->type == int_type_string)) ||
		   pike_types_le(CDDR(n)->type, string_type_string, 0, 0)) )) {
                  DBG("Match: ""F_LOOP{1453}(0 = +{1454}[ !depend_p(CAR(n), CAR(n))][ !(CAR(n)->tree_info & (OPT_SIDE_EFFECT|OPT_ASSIGNMENT|\n"
                  "\t\t\t    OPT_CASE|OPT_CONTINUE|\n"
                  "\t\t\t    OPT_BREAK|OPT_RETURN)) ], F_ADD_EQ{1455}(1 = +{1456}[ !depend_p(CADR(n), CADR(n)) ], 2 = +{1457}[ !depend_p(CDDR(n), CADR(n)) ][ !depend_p(CDDR(n), CDDR(n)) ][ !(CDDR(n)->tree_info & OPT_SIDE_EFFECT) ][ (((CDDR(n)->type == int_type_string) &&\n"
                  "\t\t    (CADR(n)->type == int_type_string)) ||\n"
                  "\t\t   pike_types_le(CDDR(n)->type, string_type_string, 0, 0)) ]))""\n");
                  {
                      
                    ADD_NODE_REF2(CADR(n),
                    ADD_NODE_REF2(CAR(n),
                    ADD_NODE_REF2(CAR(n),
                    ADD_NODE_REF2(CDDR(n),
                      tmp1 = mknode(F_POP_VALUE,
                  		mknode('?',
                  		       mkefuncallnode("`>",
                  				      mknode(F_ARG_LIST,
                  					     CAR(n), mkintnode(0))),
                  		       mknode(':',
                  			      mknode(F_ADD_EQ,
                  				     CADR(n),
                  				     mkefuncallnode("`*",
                  						    mknode(F_ARG_LIST,
                  							   CDDR(n), CAR(n)))),
                  			      mkintnode(0))),
                  		NULL);
                    ))));
                    goto use_tmp1;
                    }
                }
              }
            }
          }
        }
      }
    }
  }
  break;

case F_LOR:
  if (!CAR(n)) {
    DBG("Match: ""F_LOR{579}(-{580}, 0 = *{581})""\n");
    DBG("=> ""0 = *{582}""\n");
    goto use_cdr;
  } else if (!CDR(n)) {
    if (!CAR(n)) {
    } else {
      if ((node_is_false(CAR(n)))) {
        DBG("Match: ""F_LOR{649}(+{650}[node_is_false(CAR(n))], 0 = *{651})""\n");
        DBG("=> ""0 = *{652}""\n");
        goto use_cdr;
      }
      if ((node_is_true(CAR(n)))) {
        DBG("Match: ""F_LOR{653}(0 = +{654}[node_is_true(CAR(n))], *)""\n");
        DBG("=> ""0 = *{656}""\n");
        goto use_car;
      }
    }
    DBG("Match: ""F_LOR{583}(0 = *{584}, -{585})""\n");
    DBG("=> ""0 = *{586}""\n");
    goto use_car;
  } else {
    if (CAR(n)->token == F_APPLY) {
      if (!CAAR(n)) {
      } else {
        if (CAAR(n)->token == F_CONSTANT) {
          if ((TYPEOF(CAAR(n)->u.sval) == T_FUNCTION) &&
              (SUBTYPEOF(CAAR(n)->u.sval) == FUNCTION_BUILTIN) &&
              (CAAR(n)->u.sval.u.efun->function == f_not)) {
            if (!CDR(n)) {
            } else {
              if (CDR(n)->token == F_APPLY) {
                if (!CADR(n)) {
                } else {
                  if (CADR(n)->token == F_CONSTANT) {
                    if ((TYPEOF(CADR(n)->u.sval) == T_FUNCTION) &&
                        (SUBTYPEOF(CADR(n)->u.sval) == FUNCTION_BUILTIN) &&
                        (CADR(n)->u.sval.u.efun->function == f_not)) {
                      DBG("Match: ""F_LOR{587}(F_APPLY{588}(0 = F_CONSTANT{589}[TYPEOF(CAAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAAR(n)->u.sval) == FUNCTION_BUILTIN][CAAR(n)->u.sval.u.efun->function == f_not], 1 = *{590}), F_APPLY{591}(F_CONSTANT{592}[TYPEOF(CADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CADR(n)->u.sval) == FUNCTION_BUILTIN][CADR(n)->u.sval.u.efun->function == f_not], 2 = *{593}))""\n");
                      DBG("=> ""F_APPLY{594}""\n");
                      {
                        ADD_NODE_REF2(CAAR(n),
                        ADD_NODE_REF2(CDAR(n),
                        ADD_NODE_REF2(CDDR(n),
                          tmp1 = mknode(F_APPLY, CAAR(n), mknode(F_LAND, CDAR(n), CDDR(n)));
                        )));
                        goto use_tmp1;
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    } else if (CAR(n)->token == F_ASSIGN) {
      if (!CDAR(n)) {
      } else {
        if ((node_is_false(CDAR(n)))) {
          DBG("Match: ""F_LOR{609}(0 = F_ASSIGN{610}(*, +{612}[node_is_false(CDAR(n))]), 2 = *{613})""\n");
          DBG("=> ""F_COMMA_EXPR{614}""\n");
          {
            ADD_NODE_REF2(CAR(n),
            ADD_NODE_REF2(CDR(n),
              tmp1 = mknode(F_COMMA_EXPR, mknode(F_POP_VALUE, CAR(n), 0), CDR(n));
            ));
            goto use_tmp1;
          }
        }
        if ((node_is_true(CDAR(n)))) {
          DBG("Match: ""F_LOR{637}(0 = F_ASSIGN{638}(*, +{640}[node_is_true(CDAR(n))]), *)""\n");
          DBG("=> ""0 = *{642}""\n");
          goto use_car;
        }
      }
    } else if (CAR(n)->token == F_COMMA_EXPR) {
      if (!CDAR(n)) {
      } else {
        if ((CDAR(n)->token != F_POP_VALUE)) {
          DBG("Match: ""F_LOR{627}(F_COMMA_EXPR{628}(0 = *{629}, 1 = +{630}[CDAR(n)->token != F_POP_VALUE]), 2 = *{631})""\n");
          DBG("=> ""F_COMMA_EXPR{632}""\n");
          {
            ADD_NODE_REF2(CAAR(n),
            ADD_NODE_REF2(CDAR(n),
            ADD_NODE_REF2(CDR(n),
              tmp1 = mknode(F_COMMA_EXPR, CAAR(n), mknode(F_LOR, CDAR(n), CDR(n)));
            )));
            goto use_tmp1;
          }
        }
      }
    } else if (CAR(n)->token == F_INITIALIZE) {
      if (!CDAR(n)) {
      } else {
        if ((node_is_false(CDAR(n)))) {
          DBG("Match: ""F_LOR{619}(0 = F_INITIALIZE{620}(*, +{622}[node_is_false(CDAR(n))]), 2 = *{623})""\n");
          DBG("=> ""F_COMMA_EXPR{624}""\n");
          {
            ADD_NODE_REF2(CAR(n),
            ADD_NODE_REF2(CDR(n),
              tmp1 = mknode(F_COMMA_EXPR, CAR(n), CDR(n));
            ));
            goto use_tmp1;
          }
        }
        if ((node_is_true(CDAR(n)))) {
          DBG("Match: ""F_LOR{643}(0 = F_INITIALIZE{644}(*, +{646}[node_is_true(CDAR(n))]), *)""\n");
          DBG("=> ""0 = *{648}""\n");
          goto use_car;
        }
      }
    } else if (CAR(n)->token == F_LOR) {
      if (!CDAR(n)) {
      } else {
        if ((node_is_true(CDAR(n)))) {
          DBG("Match: ""F_LOR{657}(0 = F_LOR{658}(*, +{660}[node_is_true(CDAR(n))]), *)""\n");
          DBG("=> ""0 = *{662}""\n");
          goto use_car;
        }
      }
    }
    if (CDR(n)->token == F_LOR) {
      DBG("Match: ""F_LOR{599}(0 = *{600}, F_LOR{601}(1 = *{602}, 2 = *{603}))""\n");
      DBG("=> ""F_LOR{604}""\n");
      {
        ADD_NODE_REF2(CAR(n),
        ADD_NODE_REF2(CADR(n),
        ADD_NODE_REF2(CDDR(n),
          tmp1 = mknode(F_LOR, mknode(F_LOR, CAR(n), CADR(n)), CDDR(n));
        )));
        goto use_tmp1;
      }
    }
    if ((node_is_false(CAR(n)))) {
      DBG("Match: ""F_LOR{649}(+{650}[node_is_false(CAR(n))], 0 = *{651})""\n");
      DBG("=> ""0 = *{652}""\n");
      goto use_cdr;
    }
    if ((node_is_true(CAR(n)))) {
      DBG("Match: ""F_LOR{653}(0 = +{654}[node_is_true(CAR(n))], *)""\n");
      DBG("=> ""0 = *{656}""\n");
      goto use_car;
    }
  }
  break;

case F_LSH_EQ:
  if (!CAR(n)) {
  } else {
    DBG("Match: ""F_LSH_EQ{1484}(0 = +{1485}, 1 = *{1486})""\n");
    {
      struct pike_type *type = CAR(n)->type;
      int oper = ((CAR(n)->tree_info&(OPT_SIDE_EFFECT|OPT_ASSIGNMENT)) ||
    	      depend_p(CAR(n), CDR(n))) ? F_ASSIGN_SELF : F_ASSIGN;
      
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CDR(n),
        tmp1 = mknode( oper, CAR(n), mksoftcastnode(type,mkopernode( "`<<", CAR(n), CDR(n))));
      )));
      goto use_tmp1;
    }
  }
  break;

case F_LVALUE_LIST:
  if (!CAR(n)) {
    DBG("Match: ""F_LVALUE_LIST{545}(-{546}, 0 = *{547})""\n");
    DBG("=> ""0 = *{548}""\n");
    goto use_cdr;
  } else {
    if (CAR(n)->token == F_BREAK) {
      if (!CDR(n)) {
      } else {
        if ((!(CDR(n)->tree_info & OPT_CASE))) {
          DBG("Match: ""F_LVALUE_LIST{557}(0 = F_BREAK{558}, +{559}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
          DBG("=> ""0 = *{560}""\n");
          goto use_car;
        }
      }
    } else if (CAR(n)->token == F_COMMA_EXPR) {
      if (!CDAR(n)) {
      } else {
        if (CDAR(n)->token == F_BREAK) {
          if (!CDR(n)) {
          } else {
            if ((!(CDR(n)->tree_info & OPT_CASE))) {
              DBG("Match: ""F_LVALUE_LIST{573}(0 = F_COMMA_EXPR{574}(*, F_BREAK{576}), +{577}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
              DBG("=> ""0 = *{578}""\n");
              goto use_car;
            }
          }
        } else if (CDAR(n)->token == F_CONTINUE) {
          if (!CDR(n)) {
          } else {
            if ((!(CDR(n)->tree_info & OPT_CASE))) {
              DBG("Match: ""F_LVALUE_LIST{567}(0 = F_COMMA_EXPR{568}(*, F_CONTINUE{570}), +{571}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
              DBG("=> ""0 = *{572}""\n");
              goto use_car;
            }
          }
        } else if (CDAR(n)->token == F_RETURN) {
          if (!CDR(n)) {
          } else {
            if ((!(CDR(n)->tree_info & OPT_CASE))) {
              DBG("Match: ""F_LVALUE_LIST{561}(0 = F_COMMA_EXPR{562}(*, F_RETURN{564}), +{565}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
              DBG("=> ""0 = *{566}""\n");
              goto use_car;
            }
          }
        }
      }
    } else if (CAR(n)->token == F_CONTINUE) {
      if (!CDR(n)) {
      } else {
        if ((!(CDR(n)->tree_info & OPT_CASE))) {
          DBG("Match: ""F_LVALUE_LIST{553}(0 = F_CONTINUE{554}, +{555}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
          DBG("=> ""0 = *{556}""\n");
          goto use_car;
        }
      }
    } else if (CAR(n)->token == F_RETURN) {
      if (!CDR(n)) {
      } else {
        if ((!(CDR(n)->tree_info & OPT_CASE))) {
          DBG("Match: ""F_LVALUE_LIST{549}(0 = F_RETURN{550}, +{551}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
          DBG("=> ""0 = *{552}""\n");
          goto use_car;
        }
      }
    }
  }
  break;

case F_MOD_EQ:
  if (!CAR(n)) {
  } else {
    DBG("Match: ""F_MOD_EQ{1496}(0 = +{1497}, 1 = *{1498})""\n");
    {
      struct pike_type *type = CAR(n)->type;
      int oper = ((CAR(n)->tree_info&(OPT_SIDE_EFFECT|OPT_ASSIGNMENT)) ||
    	      depend_p(CAR(n), CDR(n))) ? F_ASSIGN_SELF : F_ASSIGN;
      
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CDR(n),
        tmp1 = mknode( oper, CAR(n), mksoftcastnode(type,mkopernode( "`%", CAR(n), CDR(n) )));
      )));
      goto use_tmp1;
    }
  }
  break;

case F_MULT_EQ:
  if (!CAR(n)) {
  } else {
    DBG("Match: ""F_MULT_EQ{1490}(0 = +{1491}, 1 = *{1492})""\n");
    {
      struct pike_type *type = CAR(n)->type;
      int oper = ((CAR(n)->tree_info&(OPT_SIDE_EFFECT|OPT_ASSIGNMENT)) ||
    	      depend_p(CAR(n), CDR(n))) ? F_ASSIGN_SELF : F_ASSIGN;
      
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CDR(n),
        tmp1 = mknode( oper, CAR(n), mksoftcastnode(type,mkopernode( "`*", CAR(n), CDR(n) )));
      )));
      goto use_tmp1;
    }
  }
  break;

case F_OR_EQ:
  if (!CAR(n)) {
  } else if (!CDR(n)) {
  } else {
    if (CDR(n)->token == F_APPLY) {
      if (!CADR(n)) {
      } else {
        if (CADR(n)->token == F_CONSTANT) {
          if ((TYPEOF(CADR(n)->u.sval) == T_FUNCTION) &&
              (SUBTYPEOF(CADR(n)->u.sval) == FUNCTION_BUILTIN) &&
              (CADR(n)->u.sval.u.efun->function == f_aggregate_mapping)) {
            DBG("Match: ""F_OR_EQ{1020}(0 = *{1021}, F_APPLY{1022}(F_CONSTANT{1023}[TYPEOF(CADR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CADR(n)->u.sval) == FUNCTION_BUILTIN][CADR(n)->u.sval.u.efun->function == f_aggregate_mapping], 1 = *{1024}))""\n");
            DBG("=> ""F_APPEND_MAPPING{1025}""\n");
            {
              ADD_NODE_REF2(CAR(n),
              ADD_NODE_REF2(CDDR(n),
                tmp1 = mknode(F_APPEND_MAPPING, CAR(n), CDDR(n));
              ));
              goto use_tmp1;
            }
          }
        }
      }
    }
    DBG("Match: ""F_OR_EQ{1478}(0 = +{1479}, 1 = *{1480})""\n");
    {
      struct pike_type *type = CAR(n)->type;
      int oper = ((CAR(n)->tree_info&(OPT_SIDE_EFFECT|OPT_ASSIGNMENT)) ||
    	      depend_p(CAR(n), CDR(n))) ? F_ASSIGN_SELF : F_ASSIGN;
      
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CDR(n),
        tmp1 = mknode( oper, CAR(n), mksoftcastnode(type,mkopernode( "`|", CAR(n), CDR(n) )));
      )));
      goto use_tmp1;
    }
  }
  break;

case F_POP_VALUE:
  if (!CAR(n)) {
    DBG("Match: ""F_POP_VALUE{140}(-{141}, *)""\n");
    DBG("=> ""-{143}""\n");
    goto zap_node;
  } else {
    if (CAR(n)->token == '?') {
      if (!CDAR(n)) {
      } else {
        if (CDAR(n)->token == ':') {
          DBG("Match: ""F_POP_VALUE{236}('?'{237}(0 = *{238}, ':'{239}(1 = *{240}, 2 = *{241})), *)""\n");
#ifdef PIKE_DEBUG
            if (l_flag > 4) {
              fprintf(stderr,
                      "Setting line position to %s:%ld\n",
                      CAR(n)->current_file->str,
                      (long)CAR(n)->line_number);
            }
#endif /* PIKE_DEBUG */
          c->lex.current_line = CAR(n)->line_number;
          c->lex.current_file = CAR(n)->current_file;
          DBG("=> ""'?'{243}""\n");
          {
            ADD_NODE_REF2(CAAR(n),
            ADD_NODE_REF2(CADAR(n),
            ADD_NODE_REF2(CDDAR(n),
              tmp1 = mknode('?', CAAR(n), mknode(':', mknode(F_POP_VALUE, CADAR(n), 0), mknode(F_POP_VALUE, CDDAR(n), 0)));
            )));
            goto use_tmp1;
          }
        }
      }
    } else if (CAR(n)->token == F_BREAK) {
      DBG("Match: ""F_POP_VALUE{188}(0 = F_BREAK{189}, *)""\n");
      DBG("=> ""0 = *{191}""\n");
      goto use_car;
    } else if (CAR(n)->token == F_CASE) {
      DBG("Match: ""F_POP_VALUE{192}(0 = F_CASE{193}, *)""\n");
      DBG("=> ""0 = *{195}""\n");
      goto use_car;
    } else if (CAR(n)->token == F_CASE_RANGE) {
      DBG("Match: ""F_POP_VALUE{196}(0 = F_CASE_RANGE{197}, *)""\n");
      DBG("=> ""0 = *{199}""\n");
      goto use_car;
    } else if (CAR(n)->token == F_CONSTANT) {
      DBG("Match: ""F_POP_VALUE{148}(F_CONSTANT{149}, *)""\n");
      DBG("=> ""-{151}""\n");
      goto zap_node;
    } else if (CAR(n)->token == F_CONTINUE) {
      DBG("Match: ""F_POP_VALUE{184}(0 = F_CONTINUE{185}, *)""\n");
      DBG("=> ""0 = *{187}""\n");
      goto use_car;
    } else if (CAR(n)->token == F_DEC_LOOP) {
      DBG("Match: ""F_POP_VALUE{216}(0 = F_DEC_LOOP{217}, *)""\n");
      DBG("=> ""0 = *{219}""\n");
      goto use_car;
    } else if (CAR(n)->token == F_DEC_NEQ_LOOP) {
      DBG("Match: ""F_POP_VALUE{224}(0 = F_DEC_NEQ_LOOP{225}, *)""\n");
      DBG("=> ""0 = *{227}""\n");
      goto use_car;
    } else if (CAR(n)->token == F_DEFAULT) {
      DBG("Match: ""F_POP_VALUE{200}(0 = F_DEFAULT{201}, *)""\n");
      DBG("=> ""0 = *{203}""\n");
      goto use_car;
    } else if (CAR(n)->token == F_EXTERNAL) {
      DBG("Match: ""F_POP_VALUE{164}(F_EXTERNAL{165}, *)""\n");
      DBG("=> ""-{167}""\n");
      goto zap_node;
    } else if (CAR(n)->token == F_FOR) {
      DBG("Match: ""F_POP_VALUE{204}(0 = F_FOR{205}, *)""\n");
      DBG("=> ""0 = *{207}""\n");
      goto use_car;
    } else if (CAR(n)->token == F_FOREACH) {
      DBG("Match: ""F_POP_VALUE{208}(0 = F_FOREACH{209}, *)""\n");
      DBG("=> ""0 = *{211}""\n");
      goto use_car;
    } else if (CAR(n)->token == F_GET_SET) {
      DBG("Match: ""F_POP_VALUE{168}(F_GET_SET{169}, *)""\n");
      DBG("=> ""-{171}""\n");
      goto zap_node;
    } else if (CAR(n)->token == F_GLOBAL) {
      DBG("Match: ""F_POP_VALUE{160}(F_GLOBAL{161}, *)""\n");
      DBG("=> ""-{163}""\n");
      goto zap_node;
    } else if (CAR(n)->token == F_INC_LOOP) {
      DBG("Match: ""F_POP_VALUE{212}(0 = F_INC_LOOP{213}, *)""\n");
      DBG("=> ""0 = *{215}""\n");
      goto use_car;
    } else if (CAR(n)->token == F_INC_NEQ_LOOP) {
      DBG("Match: ""F_POP_VALUE{220}(0 = F_INC_NEQ_LOOP{221}, *)""\n");
      DBG("=> ""0 = *{223}""\n");
      goto use_car;
    } else if (CAR(n)->token == F_LAND) {
      if (!CAAR(n)) {
      } else {
        if (CAAR(n)->token == F_APPLY) {
          if (!CAAAR(n)) {
          } else {
            if (CAAAR(n)->token == F_CONSTANT) {
              if ((TYPEOF(CAAAR(n)->u.sval) == T_FUNCTION) &&
                  (SUBTYPEOF(CAAAR(n)->u.sval) == FUNCTION_BUILTIN) &&
                  (CAAAR(n)->u.sval.u.efun->function == f_not)) {
                if (!CDAAR(n)) {
                } else {
                  if (CDAAR(n)->token == F_ARG_LIST) {
                    DBG("Match: ""F_POP_VALUE{749}(F_LAND{750}(F_APPLY{751}(F_CONSTANT{752}[TYPEOF(CAAAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAAAR(n)->u.sval) == FUNCTION_BUILTIN][CAAAR(n)->u.sval.u.efun->function == f_not], F_ARG_LIST{753}(0 = *{754}, *)), 1 = *{756}), *)""\n");
                    DBG("=> ""F_POP_VALUE{758}""\n");
                    {
                      ADD_NODE_REF2(CADAAR(n),
                      ADD_NODE_REF2(CDAR(n),
                        tmp1 = mknode(F_POP_VALUE, mknode(F_LOR, CADAAR(n), CDAR(n)), 0);
                      ));
                      goto use_tmp1;
                    }
                  }
                }
              }
            }
          }
        }
      }
    } else if (CAR(n)->token == F_LOCAL) {
      DBG("Match: ""F_POP_VALUE{156}(F_LOCAL{157}, *)""\n");
      DBG("=> ""-{159}""\n");
      goto zap_node;
    } else if (CAR(n)->token == F_LOOP) {
      DBG("Match: ""F_POP_VALUE{228}(0 = F_LOOP{229}, *)""\n");
      DBG("=> ""0 = *{231}""\n");
      goto use_car;
    } else if (CAR(n)->token == F_LOR) {
      if (!CAAR(n)) {
      } else {
        if (CAAR(n)->token == F_APPLY) {
          if (!CAAAR(n)) {
          } else {
            if (CAAAR(n)->token == F_CONSTANT) {
              if ((TYPEOF(CAAAR(n)->u.sval) == T_FUNCTION) &&
                  (SUBTYPEOF(CAAAR(n)->u.sval) == FUNCTION_BUILTIN) &&
                  (CAAAR(n)->u.sval.u.efun->function == f_not)) {
                if (!CDAAR(n)) {
                } else {
                  if (CDAAR(n)->token == F_ARG_LIST) {
                    DBG("Match: ""F_POP_VALUE{763}(F_LOR{764}(F_APPLY{765}(F_CONSTANT{766}[TYPEOF(CAAAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAAAR(n)->u.sval) == FUNCTION_BUILTIN][CAAAR(n)->u.sval.u.efun->function == f_not], F_ARG_LIST{767}(0 = *{768}, *)), 1 = *{770}), *)""\n");
                    DBG("=> ""F_POP_VALUE{772}""\n");
                    {
                      ADD_NODE_REF2(CADAAR(n),
                      ADD_NODE_REF2(CDAR(n),
                        tmp1 = mknode(F_POP_VALUE, mknode(F_LAND, CADAAR(n), CDAR(n)), 0);
                      ));
                      goto use_tmp1;
                    }
                  }
                }
              }
            }
          }
        }
      }
    } else if (CAR(n)->token == F_POP_VALUE) {
      DBG("Match: ""F_POP_VALUE{144}(0 = F_POP_VALUE{145}, *)""\n");
      DBG("=> ""0 = *{147}""\n");
      goto use_car;
    } else if (CAR(n)->token == F_RETURN) {
      if (!CDAR(n)) {
        DBG("Match: ""F_POP_VALUE{172}(0 = F_RETURN{173}(*, -{175}), *)""\n");
        DBG("=> ""0 = *{177}""\n");
        goto use_car;
      } else {
        if (CDAR(n)->token == F_CONSTANT) {
          if ((TYPEOF(CDAR(n)->u.sval) == T_INT) &&
              (!CDAR(n)->u.sval.u.integer)) {
            DBG("Match: ""F_POP_VALUE{178}(0 = F_RETURN{179}(*, F_CONSTANT{181}[TYPEOF(CDAR(n)->u.sval) == T_INT][!CDAR(n)->u.sval.u.integer]), *)""\n");
            DBG("=> ""0 = *{183}""\n");
            goto use_car;
          }
        }
      }
    } else if (CAR(n)->token == F_SWITCH) {
      DBG("Match: ""F_POP_VALUE{232}(0 = F_SWITCH{233}, *)""\n");
      DBG("=> ""0 = *{235}""\n");
      goto use_car;
    }
    if ((node_is_tossable(CAR(n)))) {
      DBG("Match: ""F_POP_VALUE{152}(+{153}[node_is_tossable(CAR(n))], *)""\n");
      DBG("=> ""-{155}""\n");
      goto zap_node;
    }
  }
  break;

case F_POW_EQ:
  if (!CAR(n)) {
  } else {
    DBG("Match: ""F_POW_EQ{1493}(0 = +{1494}, 1 = *{1495})""\n");
    {
      struct pike_type *type = CAR(n)->type;
      int oper = ((CAR(n)->tree_info&(OPT_SIDE_EFFECT|OPT_ASSIGNMENT)) ||
    	      depend_p(CAR(n), CDR(n))) ? F_ASSIGN_SELF : F_ASSIGN;
      
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CDR(n),
        tmp1 = mknode( oper, CAR(n), mksoftcastnode(type,mkopernode( "`**", CAR(n), CDR(n) )));
      )));
      goto use_tmp1;
    }
  }
  break;

case F_PUSH_ARRAY:
  if (!CAR(n)) {
  } else {
    if (CAR(n)->token == F_APPLY) {
      if (!CAAR(n)) {
      } else {
        if (CAAR(n)->token == F_CONSTANT) {
          if ((TYPEOF(CAAR(n)->u.sval) == T_FUNCTION) &&
              (SUBTYPEOF(CAAR(n)->u.sval) == FUNCTION_BUILTIN) &&
              (CAAR(n)->u.sval.u.efun->function == debug_f_aggregate)) {
            DBG("Match: ""F_PUSH_ARRAY{14}(F_APPLY{15}(F_CONSTANT{16}[TYPEOF(CAAR(n)->u.sval) == T_FUNCTION][SUBTYPEOF(CAAR(n)->u.sval) == FUNCTION_BUILTIN][CAAR(n)->u.sval.u.efun->function == debug_f_aggregate], 0 = *{17}), *)""\n");
            DBG("=> ""0 = *{19}""\n");
            {
              ADD_NODE_REF2(CDAR(n),
                tmp1 = CDAR(n);
              );
              goto use_tmp1;
            }
          }
        }
      }
    } else if (CAR(n)->token == F_CONSTANT) {
      if ((TYPEOF(CAR(n)->u.sval) == T_ARRAY)) {
        DBG("Match: ""F_PUSH_ARRAY{20}(0 = F_CONSTANT{21}[TYPEOF(CAR(n)->u.sval) == T_ARRAY], *)""\n");
        {
            struct array *a = CAR(n)->u.sval.u.array;
            node *res = NULL;
            int i;
            for(i=0; i<a->size; i++) {
              if (res) {
        	res = mknode(F_ARG_LIST, res, mksvaluenode(a->item+i));
              } else {
        	/* i is always 0 here. */
        	res = mksvaluenode(a->item);
              }
            }
            
          tmp1 = res;
          goto use_tmp1;
          }
      }
    }
  }
  break;

case F_RANGE:
  if (!CDR(n)) {
  } else {
    if (CDR(n)->token == ':') {
      if (!CADR(n)) {
      } else if (!CDDR(n)) {
      } else {
        if (CADR(n)->token == F_RANGE_FROM_BEG) {
          if (!CAADR(n)) {
          } else {
            if (CAADR(n)->token == F_CONSTANT) {
              if ((TYPEOF(CAADR(n)->u.sval) == T_INT)) {
                if (!CDDR(n)) {
                } else {
                  if (CDDR(n)->token == F_RANGE_FROM_BEG) {
                    if (!CADDR(n)) {
                    } else {
                      if (CADDR(n)->token == F_CONSTANT) {
                        if ((TYPEOF(CADDR(n)->u.sval) == T_INT) &&
                            (CADDR(n)->u.sval.u.integer < CAADR(n)->u.sval.u.integer)) {
                          DBG("Match: ""F_RANGE{290}(0 = *{291}, ':'{292}(F_RANGE_FROM_BEG{293}(1 = F_CONSTANT{294}[TYPEOF(CAADR(n)->u.sval) == T_INT], *), F_RANGE_FROM_BEG{296}(F_CONSTANT{297}[TYPEOF(CADDR(n)->u.sval) == T_INT][CADDR(n)->u.sval.u.integer < CAADR(n)->u.sval.u.integer], *)))""\n");
                          {
                            /* Objects may want to use the range for obscure purposes. */
                            if (!match_types(object_type_string, CAR(n)->type)) {
                              yywarning("Range is always empty.");
                              if (pike_types_le(CAR(n)->type, string_type_string, 0, 0)) {
                                
                            tmp1 = mkstrnode(empty_pike_string);
                            goto use_tmp1;
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        } else if (CADR(n)->token == F_RANGE_OPEN) {
          if (!CDDR(n)) {
          } else {
            if (CDDR(n)->token == F_RANGE_OPEN) {
              DBG("Match: ""F_RANGE{285}(0 = *{286}, ':'{287}(F_RANGE_OPEN{288}, F_RANGE_OPEN{289}))""\n");
              {
                /* Objects may want to use the range for obscure purposes. */
                if (!match_types(object_type_string, CAR(n)->type)) {
                  yywarning("Redundant range operator.");
                  
                ADD_NODE_REF2(CAR(n),
                  tmp1 = CAR(n);
                );
                goto use_tmp1;
                }
              }
            }
          }
        }
        if (CDDR(n)->token == F_RANGE_FROM_BEG) {
          if (!CADDR(n)) {
          } else {
            if (CADDR(n)->token == F_CONSTANT) {
              if ((TYPEOF(CADDR(n)->u.sval) == T_FLOAT) &&
                  (CADDR(n)->u.sval.u.float_number < 0.0)) {
                DBG("Match: ""F_RANGE{278}(*, ':'{280}(*, F_RANGE_FROM_BEG{282}(F_CONSTANT{283}[TYPEOF(CADDR(n)->u.sval) == T_FLOAT][CADDR(n)->u.sval.u.float_number < 0.0], *)))""\n");
                {
                  yywarning("Range end is negative.");
                }
              }
              if ((TYPEOF(CADDR(n)->u.sval) == T_INT) &&
                  (CADDR(n)->u.sval.u.integer < 0)) {
                DBG("Match: ""F_RANGE{271}(*, ':'{273}(*, F_RANGE_FROM_BEG{275}(F_CONSTANT{276}[TYPEOF(CADDR(n)->u.sval) == T_INT][CADDR(n)->u.sval.u.integer < 0], *)))""\n");
                {
                  yywarning("Range end is negative.");
                }
              }
            }
          }
        }
      }
    }
  }
  break;

case F_RSH_EQ:
  if (!CAR(n)) {
  } else {
    DBG("Match: ""F_RSH_EQ{1487}(0 = +{1488}, 1 = *{1489})""\n");
    {
      struct pike_type *type = CAR(n)->type;
      int oper = ((CAR(n)->tree_info&(OPT_SIDE_EFFECT|OPT_ASSIGNMENT)) ||
    	      depend_p(CAR(n), CDR(n))) ? F_ASSIGN_SELF : F_ASSIGN;
      
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CDR(n),
        tmp1 = mknode( oper, CAR(n), mksoftcastnode(type,mkopernode( "`>>", CAR(n), CDR(n))));
      )));
      goto use_tmp1;
    }
  }
  break;

case F_SSCANF:
  if (!CAR(n)) {
  } else {
    if (CAR(n)->token == F_ARG_LIST) {
      if (!CAAR(n)) {
      } else {
        if (CAAR(n)->token == F_RANGE) {
          if (!CAAAR(n)) {
          } else {
            if (( pike_types_le(CAAAR(n)->type,
                                                 string_type_string, 0, 0))) {
              if (!CDAAR(n)) {
              } else {
                if (CDAAR(n)->token == ':') {
                  if (!CADAAR(n)) {
                  } else {
                    if (CADAAR(n)->token == F_RANGE_FROM_BEG) {
                      if (!CDADAAR(n)) {
                        if (!CAADAAR(n)) {
                        } else {
                          if (( pike_types_le(CAADAAR(n)->type,
                                                                      int_type_string, 0, 0))) {
                            if (!CDDAAR(n)) {
                            } else {
                              if (CDDAAR(n)->token == F_RANGE_OPEN) {
                                if (!CDAR(n)) {
                                } else {
                                  DBG("Match: ""F_SSCANF{95}(F_ARG_LIST{96}(F_RANGE{97}(0 = +{98}[ pike_types_le(CAAAR(n)->type,\n"
                                  "                                                 string_type_string, 0, 0)], ':'{99}(F_RANGE_FROM_BEG{100}(1 = +{101}[ pike_types_le(CAADAAR(n)->type,\n"
                                  "                                                                      int_type_string, 0, 0)], -{102}), F_RANGE_OPEN{103})), 2 = +{104}), 3 = *{105})""\n");
                                  {
                                    struct pike_string *percent_star_string;
                                    struct pike_string *s_string;
                                    MAKE_CONST_STRING(percent_star_string, "%*!");
                                    MAKE_CONST_STRING(s_string, "s");
                                    
                                    ADD_NODE_REF2(CAAAR(n),
                                    ADD_NODE_REF2(CAADAAR(n),
                                    ADD_NODE_REF2(CDAR(n),
                                    ADD_NODE_REF2(CDR(n),
                                      tmp1 = mkopernode("`-",
                                  		  mknode(F_LOR,
                                  			 mknode(F_SSCANF,
                                  				mknode(F_ARG_LIST, CAAAR(n),
                                  				       mkopernode("`+",
                                  						  mknode(F_ARG_LIST,
                                  							 mkstrnode(percent_star_string),
                                  							 CAADAAR(n)),
                                  						  mknode(F_ARG_LIST,
                                  							 mkstrnode(s_string),
                                  							 CDAR(n)))),
                                  				CDR(n)),
                                  			 mkintnode(1)),
                                  		  mkintnode(1));
                                    ))));
                                    goto use_tmp1;
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  break;

case F_SSCANF_80:
  if (!CAR(n)) {
  } else {
    if (CAR(n)->token == F_ARG_LIST) {
      if (!CAAR(n)) {
      } else {
        if (CAAR(n)->token == F_RANGE) {
          if (!CAAAR(n)) {
          } else {
            if (( pike_types_le(CAAAR(n)->type,
						    string_type_string, 0, 0))) {
              if (!CDAAR(n)) {
              } else {
                if (CDAAR(n)->token == ':') {
                  if (!CADAAR(n)) {
                  } else {
                    if (CADAAR(n)->token == F_RANGE_FROM_BEG) {
                      if (!CDADAAR(n)) {
                        if (!CAADAAR(n)) {
                        } else {
                          if (( pike_types_le(CAADAAR(n)->type,
									 int_type_string, 0, 0))) {
                            if (!CDDAAR(n)) {
                            } else {
                              if (CDDAAR(n)->token == F_RANGE_OPEN) {
                                if (!CDAR(n)) {
                                } else {
                                  DBG("Match: ""F_SSCANF_80{106}(F_ARG_LIST{107}(F_RANGE{108}(0 = +{109}[ pike_types_le(CAAAR(n)->type,\n"
                                  "\t\t\t\t\t\t    string_type_string, 0, 0)], ':'{110}(F_RANGE_FROM_BEG{111}(1 = +{112}[ pike_types_le(CAADAAR(n)->type,\n"
                                  "\t\t\t\t\t\t\t\t\t int_type_string, 0, 0)], -{113}), F_RANGE_OPEN{114})), 2 = +{115}), 3 = *{116})""\n");
                                  {
                                    struct pike_string *percent_star_string;
                                    struct pike_string *s_string;
                                    MAKE_CONST_STRING(percent_star_string, "%*!");
                                    MAKE_CONST_STRING(s_string, "s");
                                    
                                    ADD_NODE_REF2(CAAAR(n),
                                    ADD_NODE_REF2(CAADAAR(n),
                                    ADD_NODE_REF2(CDAR(n),
                                    ADD_NODE_REF2(CDR(n),
                                      tmp1 = mkopernode("`-",
                                  		  mknode(F_LOR,
                                  			 mknode(F_SSCANF_80,
                                  				mknode(F_ARG_LIST, CAAAR(n),
                                  				       mkopernode("`+",
                                  						  mknode(F_ARG_LIST,
                                  							 mkstrnode(percent_star_string),
                                  							 CAADAAR(n)),
                                  						  mknode(F_ARG_LIST,
                                  							 mkstrnode(s_string),
                                  							 CDAR(n)))),
                                  				CDR(n)),
                                  			 mkintnode(1)),
                                  		  mkintnode(1));
                                    ))));
                                    goto use_tmp1;
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  break;

case F_SUB_EQ:
  if (!CAR(n)) {
  } else if (!CDR(n)) {
  } else {
    if (CDR(n)->token == F_CONSTANT) {
      if ((TYPEOF(CDR(n)->u.sval) == T_INT) &&
          ((CDR(n)->u.sval.u.integer) == -1)) {
        DBG("Match: ""F_SUB_EQ{998}(0 = *{999}, 1 = F_CONSTANT{1000}[TYPEOF(CDR(n)->u.sval) == T_INT][(CDR(n)->u.sval.u.integer) == -1])""\n");
        DBG("=> ""F_INC{1001}""\n");
        {
          ADD_NODE_REF2(CAR(n),
            tmp1 = mknode(F_INC, CAR(n), mkintnode(1));
          );
          goto use_tmp1;
        }
      }
      if ((TYPEOF(CDR(n)->u.sval) == T_INT) &&
          ((CDR(n)->u.sval.u.integer) == 1)) {
        DBG("Match: ""F_SUB_EQ{992}(0 = *{993}, 1 = F_CONSTANT{994}[TYPEOF(CDR(n)->u.sval) == T_INT][(CDR(n)->u.sval.u.integer) == 1])""\n");
        DBG("=> ""F_DEC{995}""\n");
        {
          ADD_NODE_REF2(CAR(n),
            tmp1 = mknode(F_DEC, CAR(n), mkintnode(1));
          );
          goto use_tmp1;
        }
      }
    }
    if (( CAR(n)->token != F_AUTO_MAP_MARKER )) {
      if (!CDR(n)) {
      } else {
        if (CDR(n)->token == F_CONSTANT) {
          if ((TYPEOF(CDR(n)->u.sval) == T_INT) &&
              (!(CDR(n)->u.sval.u.integer))) {
            DBG("Match: ""F_SUB_EQ{988}(0 = +{989}[ CAR(n)->token != F_AUTO_MAP_MARKER ], 1 = F_CONSTANT{990}[TYPEOF(CDR(n)->u.sval) == T_INT][!(CDR(n)->u.sval.u.integer)])""\n");
            DBG("=> ""0 = *{991}""\n");
            goto use_car;
          }
        }
      }
    }
    DBG("Match: ""F_SUB_EQ{1472}(0 = +{1473}, 1 = *{1474})""\n");
    {
      struct pike_type *type = CAR(n)->type;
      int oper = ((CAR(n)->tree_info&(OPT_SIDE_EFFECT|OPT_ASSIGNMENT)) ||
    	      depend_p(CAR(n), CDR(n))) ? F_ASSIGN_SELF : F_ASSIGN;
      
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CDR(n),
        tmp1 = mknode( oper, CAR(n), mksoftcastnode(type,mkopernode( "`-", CAR(n), CDR(n) )));
      )));
      goto use_tmp1;
    }
  }
  break;

case F_TYPEOF:
  if (!CAR(n)) {
    DBG("Match: ""F_TYPEOF{1505}(-{1506}, *)""\n");
    {
      
      tmp1 = mktypenode(mixed_type_string);
      goto use_tmp1;
    }
  } else {
    DBG("Match: ""F_TYPEOF{1502}(0 = +{1503}, *)""\n");
    {
      /* NB: Use an intermediate variable for the type
       *     to avoid adding an extra reference to CAR(n).
       */
      struct pike_type *t = CAR(n)->type;
      
      tmp1 = mktypenode(t);
      goto use_tmp1;
    }
  }
  break;

case F_XOR_EQ:
  if (!CAR(n)) {
  } else {
    DBG("Match: ""F_XOR_EQ{1481}(0 = +{1482}, 1 = *{1483})""\n");
    {
      struct pike_type *type = CAR(n)->type;
      int oper = ((CAR(n)->tree_info&(OPT_SIDE_EFFECT|OPT_ASSIGNMENT)) ||
    	      depend_p(CAR(n), CDR(n))) ? F_ASSIGN_SELF : F_ASSIGN;
      
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CAR(n),
      ADD_NODE_REF2(CDR(n),
        tmp1 = mknode( oper, CAR(n), mksoftcastnode(type,mkopernode( "`^", CAR(n), CDR(n) )));
      )));
      goto use_tmp1;
    }
  }
  break;

