(* Copyright (C) 1990, Digital Equipment Corporation           *)
(* All rights reserved.                                        *)
(* See the file COPYRIGHT for a full description.              *)

MODULE M3AST_AS_Iter;

IMPORT AST, M3AST_AS;
IMPORT M3AST_AS_F;

IMPORT AST_Iter;
IMPORT SeqM3AST_AS_IMPORTED, 
    SeqM3AST_AS_Used_interface_id, SeqM3AST_AS_Used_def_id,
    SeqM3AST_AS_Import_item, SeqM3AST_AS_F_Interface_id,
    SeqM3AST_AS_REVELATION, SeqM3AST_AS_DECL_REVL, SeqM3AST_AS_Const_decl, 
    SeqM3AST_AS_TYPE_DECL, SeqM3AST_AS_Var_decl, SeqM3AST_AS_Exc_decl, 
    SeqM3AST_AS_Var_id, SeqM3AST_AS_Enum_id, 
    SeqM3AST_AS_Field_id, SeqM3AST_AS_FORMAL_ID, SeqM3AST_AS_Qual_used_id, 
    SeqM3AST_AS_Fields, SeqM3AST_AS_Method, SeqM3AST_AS_M3TYPE, 
    SeqM3AST_AS_Formal_param, SeqM3AST_AS_CONS_ELEM, 
    SeqM3AST_AS_EXP, SeqM3AST_AS_Actual, SeqM3AST_AS_Case, SeqM3AST_AS_STM, 
    SeqM3AST_AS_Elsif, SeqM3AST_AS_Tcase, SeqM3AST_AS_Handler, 
    SeqM3AST_AS_Binding, SeqM3AST_AS_RANGE_EXP, SeqM3AST_AS_Override;

IMPORT M3AST_AS_Iter_rep;

PROCEDURE By_next(iter: By_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_exp;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END By_next;

TYPE
  By_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.By;
  OVERRIDES
    next := By_next;
  END;

PROCEDURE Binding_next(iter: Binding_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_id;

    | 1 => 
        r := iter.n.as_exp;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Binding_next;

TYPE
  Binding_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Binding;
  OVERRIDES
    next := Binding_next;
  END;

PROCEDURE Handler_next(iter: Handler_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  VAR
    node0: M3AST_AS.Qual_used_id;
    node1: M3AST_AS.STM;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_Qual_used_id.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 1 => 
          r := iter.n.as_id;
          EXIT;

      | 2 => 
          IF SeqM3AST_AS_STM.Next(iter.iter1, node1) THEN
            r := node1;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Handler_next;

TYPE
  Handler_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Handler;
    iter0: SeqM3AST_AS_Qual_used_id.Iter;
    iter1: SeqM3AST_AS_STM.Iter;
  OVERRIDES
    next := Handler_next;
  END;

PROCEDURE Tcase_next(iter: Tcase_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.M3TYPE;
    node1: M3AST_AS.STM;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_M3TYPE.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 1 => 
          r := iter.n.as_id;
          EXIT;

      | 2 => 
          IF SeqM3AST_AS_STM.Next(iter.iter1, node1) THEN
            r := node1;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Tcase_next;

TYPE
  Tcase_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Tcase;
    iter0: SeqM3AST_AS_M3TYPE.Iter;
    iter1: SeqM3AST_AS_STM.Iter;
  OVERRIDES
    next := Tcase_next;
  END;

PROCEDURE Try_finally_next(iter: Try_finally_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.STM;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_STM.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Try_finally_next;

TYPE
  Try_finally_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Try_finally;
    iter0: SeqM3AST_AS_STM.Iter;
  OVERRIDES
    next := Try_finally_next;
  END;

PROCEDURE Try_except_next(iter: Try_except_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  VAR
    node0: M3AST_AS.Handler;
    node1: M3AST_AS.STM;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_Handler.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 1 => 
          r := iter.n.as_else;
          EXIT;

      | 2 => 
          IF SeqM3AST_AS_STM.Next(iter.iter1, node1) THEN
            r := node1;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Try_except_next;

TYPE
  Try_except_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Try_except;
    iter0: SeqM3AST_AS_Handler.Iter;
    iter1: SeqM3AST_AS_STM.Iter;
  OVERRIDES
    next := Try_except_next;
  END;

PROCEDURE Elsif_next(iter: Elsif_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.STM;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          r := iter.n.as_exp;
          EXIT;

      | 1 => 
          IF SeqM3AST_AS_STM.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Elsif_next;

TYPE
  Elsif_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Elsif;
    iter0: SeqM3AST_AS_STM.Iter;
  OVERRIDES
    next := Elsif_next;
  END;

PROCEDURE Else_stm_next(iter: Else_stm_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  VAR
    node0: M3AST_AS.STM;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_STM.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Else_stm_next;

TYPE
  Else_stm_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Else_stm;
    iter0: SeqM3AST_AS_STM.Iter;
  OVERRIDES
    next := Else_stm_next;
  END;

PROCEDURE Case_next(iter: Case_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.RANGE_EXP;
    node1: M3AST_AS.STM;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_RANGE_EXP.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 1 => 
          IF SeqM3AST_AS_STM.Next(iter.iter1, node1) THEN
            r := node1;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Case_next;

TYPE
  Case_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Case;
    iter0: SeqM3AST_AS_RANGE_EXP.Iter;
    iter1: SeqM3AST_AS_STM.Iter;
  OVERRIDES
    next := Case_next;
  END;

PROCEDURE Block_next(iter: Block_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.DECL_REVL;
    node1: M3AST_AS.STM;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_DECL_REVL.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 1 => 
          IF SeqM3AST_AS_STM.Next(iter.iter1, node1) THEN
            r := node1;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Block_next;

TYPE
  Block_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Block;
    iter0: SeqM3AST_AS_DECL_REVL.Iter;
    iter1: SeqM3AST_AS_STM.Iter;
  OVERRIDES
    next := Block_next;
  END;

PROCEDURE With_st_next(iter: With_st_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  VAR
    node0: M3AST_AS.Binding;
    node1: M3AST_AS.STM;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_Binding.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 1 => 
          IF SeqM3AST_AS_STM.Next(iter.iter1, node1) THEN
            r := node1;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END With_st_next;

TYPE
  With_st_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.With_st;
    iter0: SeqM3AST_AS_Binding.Iter;
    iter1: SeqM3AST_AS_STM.Iter;
  OVERRIDES
    next := With_st_next;
  END;

PROCEDURE While_st_next(iter: While_st_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  VAR
    node0: M3AST_AS.STM;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          r := iter.n.as_exp;
          EXIT;

      | 1 => 
          IF SeqM3AST_AS_STM.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END While_st_next;

TYPE
  While_st_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.While_st;
    iter0: SeqM3AST_AS_STM.Iter;
  OVERRIDES
    next := While_st_next;
  END;

PROCEDURE Typecase_st_next(iter: Typecase_st_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.Tcase;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          r := iter.n.as_exp;
          EXIT;

      | 1 => 
          IF SeqM3AST_AS_Tcase.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 2 => 
          r := iter.n.as_else;
          EXIT;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Typecase_st_next;

TYPE
  Typecase_st_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Typecase_st;
    iter0: SeqM3AST_AS_Tcase.Iter;
  OVERRIDES
    next := Typecase_st_next;
  END;

PROCEDURE Try_st_next(iter: Try_st_iter; VAR r: AST.NODE): BOOLEAN RAISES {
    }=
  VAR
    node0: M3AST_AS.STM;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_STM.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 1 => 
          r := iter.n.as_try_tail;
          EXIT;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Try_st_next;

TYPE
  Try_st_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Try_st;
    iter0: SeqM3AST_AS_STM.Iter;
  OVERRIDES
    next := Try_st_next;
  END;

PROCEDURE Return_st_next(iter: Return_st_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_exp;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Return_st_next;

TYPE
  Return_st_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Return_st;
  OVERRIDES
    next := Return_st_next;
  END;

PROCEDURE Repeat_st_next(iter: Repeat_st_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  VAR
    node0: M3AST_AS.STM;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_STM.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 1 => 
          r := iter.n.as_exp;
          EXIT;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Repeat_st_next;

TYPE
  Repeat_st_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Repeat_st;
    iter0: SeqM3AST_AS_STM.Iter;
  OVERRIDES
    next := Repeat_st_next;
  END;

PROCEDURE Raise_st_next(iter: Raise_st_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_qual_id;

    | 1 => 
        r := iter.n.as_exp_void;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Raise_st_next;

TYPE
  Raise_st_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Raise_st;
  OVERRIDES
    next := Raise_st_next;
  END;

PROCEDURE Loop_st_next(iter: Loop_st_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  VAR
    node0: M3AST_AS.STM;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_STM.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Loop_st_next;

TYPE
  Loop_st_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Loop_st;
    iter0: SeqM3AST_AS_STM.Iter;
  OVERRIDES
    next := Loop_st_next;
  END;

PROCEDURE Lock_st_next(iter: Lock_st_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  VAR
    node0: M3AST_AS.STM;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          r := iter.n.as_exp;
          EXIT;

      | 1 => 
          IF SeqM3AST_AS_STM.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Lock_st_next;

TYPE
  Lock_st_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Lock_st;
    iter0: SeqM3AST_AS_STM.Iter;
  OVERRIDES
    next := Lock_st_next;
  END;

PROCEDURE If_st_next(iter: If_st_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.STM;
    node1: M3AST_AS.Elsif;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          r := iter.n.as_exp;
          EXIT;

      | 1 => 
          IF SeqM3AST_AS_STM.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 2 => 
          IF SeqM3AST_AS_Elsif.Next(iter.iter1, node1) THEN
            r := node1;
            RETURN TRUE;
          END;

      | 3 => 
          r := iter.n.as_else;
          EXIT;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END If_st_next;

TYPE
  If_st_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.If_st;
    iter0: SeqM3AST_AS_STM.Iter;
    iter1: SeqM3AST_AS_Elsif.Iter;
  OVERRIDES
    next := If_st_next;
  END;

PROCEDURE For_st_next(iter: For_st_iter; VAR r: AST.NODE): BOOLEAN RAISES {
    }=
  VAR
    node0: M3AST_AS.STM;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          r := iter.n.as_id;
          EXIT;

      | 1 => 
          r := iter.n.as_from;
          EXIT;

      | 2 => 
          r := iter.n.as_to;
          EXIT;

      | 3 => 
          r := iter.n.as_by;
          EXIT;

      | 4 => 
          IF SeqM3AST_AS_STM.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END For_st_next;

TYPE
  For_st_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.For_st;
    iter0: SeqM3AST_AS_STM.Iter;
  OVERRIDES
    next := For_st_next;
  END;

PROCEDURE Exit_st_next(iter: Exit_st_iter; <*UNUSED*> VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Exit_st_next;

TYPE
  Exit_st_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Exit_st;
  OVERRIDES
    next := Exit_st_next;
  END;

PROCEDURE Eval_st_next(iter: Eval_st_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_exp;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Eval_st_next;

TYPE
  Eval_st_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Eval_st;
  OVERRIDES
    next := Eval_st_next;
  END;

PROCEDURE Case_st_next(iter: Case_st_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  VAR
    node0: M3AST_AS.Case;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          r := iter.n.as_exp;
          EXIT;

      | 1 => 
          IF SeqM3AST_AS_Case.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 2 => 
          r := iter.n.as_else;
          EXIT;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Case_st_next;

TYPE
  Case_st_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Case_st;
    iter0: SeqM3AST_AS_Case.Iter;
  OVERRIDES
    next := Case_st_next;
  END;

PROCEDURE Call_st_next(iter: Call_st_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_call;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Call_st_next;

TYPE
  Call_st_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Call_st;
  OVERRIDES
    next := Call_st_next;
  END;

PROCEDURE Assign_st_next(iter: Assign_st_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_lhs_exp;

    | 1 => 
        r := iter.n.as_rhs_exp;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Assign_st_next;

TYPE
  Assign_st_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Assign_st;
  OVERRIDES
    next := Assign_st_next;
  END;

PROCEDURE Actual_next(iter: Actual_iter; VAR r: AST.NODE): BOOLEAN RAISES {
    }=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_id;

    | 1 => 
        r := iter.n.as_exp_type;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Actual_next;

TYPE
  Actual_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Actual;
  OVERRIDES
    next := Actual_next;
  END;

PROCEDURE Index_next(iter: Index_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.EXP;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          r := iter.n.as_array;
          EXIT;

      | 1 => 
          IF SeqM3AST_AS_EXP.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Index_next;

TYPE
  Index_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Index;
    iter0: SeqM3AST_AS_EXP.Iter;
  OVERRIDES
    next := Index_next;
  END;

PROCEDURE Call_next(iter: Call_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.Actual;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          r := iter.n.as_callexp;
          EXIT;

      | 1 => 
          IF SeqM3AST_AS_Actual.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Call_next;

TYPE
  Call_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Call;
    iter0: SeqM3AST_AS_Actual.Iter;
  OVERRIDES
    next := Call_next;
  END;

PROCEDURE Unary_next(iter: Unary_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_unary_op;

    | 1 => 
        r := iter.n.as_exp;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Unary_next;

TYPE
  Unary_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Unary;
  OVERRIDES
    next := Unary_next;
  END;

PROCEDURE Binary_next(iter: Binary_iter; VAR r: AST.NODE): BOOLEAN RAISES {
    }=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_binary_op;

    | 1 => 
        r := iter.n.as_exp1;

    | 2 => 
        r := iter.n.as_exp2;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Binary_next;

TYPE
  Binary_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Binary;
  OVERRIDES
    next := Binary_next;
  END;

PROCEDURE Propagate_next(iter: Propagate_iter; <*UNUSED*> VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Propagate_next;

TYPE
  Propagate_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Propagate;
  OVERRIDES
    next := Propagate_next;
  END;

PROCEDURE Actual_elem_next(iter: Actual_elem_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_actual;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Actual_elem_next;

TYPE
  Actual_elem_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Actual_elem;
  OVERRIDES
    next := Actual_elem_next;
  END;

PROCEDURE RANGE_EXP_elem_next(iter: RANGE_EXP_elem_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_range_exp;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END RANGE_EXP_elem_next;

TYPE
  RANGE_EXP_elem_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.RANGE_EXP_elem;
  OVERRIDES
    next := RANGE_EXP_elem_next;
  END;

PROCEDURE Constructor_next(iter: Constructor_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.CONS_ELEM;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          r := iter.n.as_type;
          EXIT;

      | 1 => 
          IF SeqM3AST_AS_CONS_ELEM.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 2 => 
          r := iter.n.as_propagate;
          EXIT;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Constructor_next;

TYPE
  Constructor_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Constructor;
    iter0: SeqM3AST_AS_CONS_ELEM.Iter;
  OVERRIDES
    next := Constructor_next;
  END;

PROCEDURE Range_next(iter: Range_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_exp1;

    | 1 => 
        r := iter.n.as_exp2;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Range_next;

TYPE
  Range_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Range;
  OVERRIDES
    next := Range_next;
  END;

PROCEDURE Range_EXP_next(iter: Range_EXP_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_exp;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Range_EXP_next;

TYPE
  Range_EXP_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Range_EXP;
  OVERRIDES
    next := Range_EXP_next;
  END;

PROCEDURE Raisees_some_next(iter: Raisees_some_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  VAR
    node0: M3AST_AS.Qual_used_id;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_Qual_used_id.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Raisees_some_next;

TYPE
  Raisees_some_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Raisees_some;
    iter0: SeqM3AST_AS_Qual_used_id.Iter;
  OVERRIDES
    next := Raisees_some_next;
  END;

PROCEDURE Formal_param_next(iter: Formal_param_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.FORMAL_ID;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_FORMAL_ID.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 1 => 
          r := iter.n.as_formal_type;
          EXIT;

      | 2 => 
          r := iter.n.as_default;
          EXIT;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Formal_param_next;

TYPE
  Formal_param_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Formal_param;
    iter0: SeqM3AST_AS_FORMAL_ID.Iter;
  OVERRIDES
    next := Formal_param_next;
  END;

PROCEDURE Method_next(iter: Method_iter; VAR r: AST.NODE): BOOLEAN RAISES {
    }=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_id;

    | 1 => 
        r := iter.n.as_type;

    | 2 => 
        r := iter.n.as_default;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Method_next;

TYPE
  Method_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Method;
  OVERRIDES
    next := Method_next;
  END;

PROCEDURE Override_next(iter: Override_iter; VAR r: AST.NODE): BOOLEAN RAISES {
    }=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_id;

    | 1 => 
        r := iter.n.as_default;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Override_next;

TYPE
  Override_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Override;
  OVERRIDES
    next := Override_next;
  END;


PROCEDURE Fields_next(iter: Fields_iter; VAR r: AST.NODE): BOOLEAN RAISES {
    }=
  VAR
    node0: M3AST_AS.Field_id;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_Field_id.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 1 => 
          r := iter.n.as_type;
          EXIT;

      | 2 => 
          r := iter.n.as_default;
          EXIT;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Fields_next;

TYPE
  Fields_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Fields;
    iter0: SeqM3AST_AS_Field_id.Iter;
  OVERRIDES
    next := Fields_next;
  END;

PROCEDURE Brand_next(iter: Brand_iter; VAR r: AST.NODE): BOOLEAN RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_exp;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Brand_next;

TYPE
  Brand_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Brand;
  OVERRIDES
    next := Brand_next;
  END;

PROCEDURE Opaque_type_next(iter: Opaque_type_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_type;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Opaque_type_next;

TYPE
  Opaque_type_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Opaque_type;
  OVERRIDES
    next := Opaque_type_next;
  END;

PROCEDURE Packed_type_next(iter: Packed_type_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_exp;

    | 1 => 
        r := iter.n.as_type;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Packed_type_next;

TYPE
  Packed_type_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Packed_type;
  OVERRIDES
    next := Packed_type_next;
  END;

PROCEDURE Ref_type_next(iter: Ref_type_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_trace_mode;

    | 1 => 
        r := iter.n.as_brand;

    | 2 => 
        r := iter.n.as_type;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Ref_type_next;

TYPE
  Ref_type_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Ref_type;
  OVERRIDES
    next := Ref_type_next;
  END;

PROCEDURE Procedure_type_next(iter: Procedure_type_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.Formal_param;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_Formal_param.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 1 => 
          r := iter.n.as_result_type;
          EXIT;

      | 2 => 
          r := iter.n.as_raises;
          EXIT;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Procedure_type_next;

TYPE
  Procedure_type_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Procedure_type;
    iter0: SeqM3AST_AS_Formal_param.Iter;
  OVERRIDES
    next := Procedure_type_next;
  END;

PROCEDURE Set_type_next(iter: Set_type_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_type;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Set_type_next;

TYPE
  Set_type_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Set_type;
  OVERRIDES
    next := Set_type_next;
  END;

PROCEDURE Object_type_next(iter: Object_type_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.Fields;
    node1: M3AST_AS.Method;
    node2: M3AST_AS.Override;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          r := iter.n.as_ancestor;
          EXIT;

      | 1 => 
          r := iter.n.as_brand;
          EXIT;

      | 2 => 
          IF SeqM3AST_AS_Fields.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 3 => 
          IF SeqM3AST_AS_Method.Next(iter.iter1, node1) THEN
            r := node1;
            RETURN TRUE;
          END;

      | 4 =>
          IF SeqM3AST_AS_Override.Next(iter.iter2, node2) THEN
            r := node2;
            RETURN TRUE;
          END; (* if *)

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Object_type_next;

TYPE
  Object_type_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Object_type;
    iter0: SeqM3AST_AS_Fields.Iter;
    iter1: SeqM3AST_AS_Method.Iter;
    iter2: SeqM3AST_AS_Override.Iter;
  OVERRIDES
    next := Object_type_next;
  END;

PROCEDURE Record_type_next(iter: Record_type_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.Fields;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_Fields.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Record_type_next;

TYPE
  Record_type_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Record_type;
    iter0: SeqM3AST_AS_Fields.Iter;
  OVERRIDES
    next := Record_type_next;
  END;

PROCEDURE Array_type_next(iter: Array_type_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  VAR
    node0: M3AST_AS.M3TYPE;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_M3TYPE.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 1 => 
          r := iter.n.as_elementtype;
          EXIT;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Array_type_next;

TYPE
  Array_type_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Array_type;
    iter0: SeqM3AST_AS_M3TYPE.Iter;
  OVERRIDES
    next := Array_type_next;
  END;

PROCEDURE Subrange_type_next(iter: Subrange_type_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_range;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Subrange_type_next;

TYPE
  Subrange_type_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Subrange_type;
  OVERRIDES
    next := Subrange_type_next;
  END;

PROCEDURE Enumeration_type_next(iter: Enumeration_type_iter; 
    VAR r: AST.NODE): BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.Enum_id;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_Enum_id.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Enumeration_type_next;

TYPE
  Enumeration_type_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Enumeration_type;
    iter0: SeqM3AST_AS_Enum_id.Iter;
  OVERRIDES
    next := Enumeration_type_next;
  END;

PROCEDURE Root_type_next(iter: Root_type_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_trace_mode;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Root_type_next;

TYPE
  Root_type_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Root_type;
  OVERRIDES
    next := Root_type_next;
  END;

PROCEDURE Named_type_next(iter: Named_type_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_qual_id;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Named_type_next;

TYPE
  Named_type_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Named_type;
  OVERRIDES
    next := Named_type_next;
  END;

PROCEDURE Concrete_reveal_next(iter: Concrete_reveal_iter; VAR r: AST.NODE)
    : BOOLEAN RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_qual_id;

    | 1 => 
        r := iter.n.as_type;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Concrete_reveal_next;

TYPE
  Concrete_reveal_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Concrete_reveal;
  OVERRIDES
    next := Concrete_reveal_next;
  END;

PROCEDURE Subtype_reveal_next(iter: Subtype_reveal_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_qual_id;

    | 1 => 
        r := iter.n.as_type;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Subtype_reveal_next;

TYPE
  Subtype_reveal_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Subtype_reveal;
  OVERRIDES
    next := Subtype_reveal_next;
  END;

PROCEDURE Concrete_decl_next(iter: Concrete_decl_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_id;

    | 1 => 
        r := iter.n.as_type;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Concrete_decl_next;

TYPE
  Concrete_decl_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Concrete_decl;
  OVERRIDES
    next := Concrete_decl_next;
  END;

PROCEDURE Subtype_decl_next(iter: Subtype_decl_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_id;

    | 1 => 
        r := iter.n.as_type;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Subtype_decl_next;

TYPE
  Subtype_decl_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Subtype_decl;
  OVERRIDES
    next := Subtype_decl_next;
  END;

PROCEDURE Exc_decl_next(iter: Exc_decl_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_id;

    | 1 => 
        r := iter.n.as_type;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Exc_decl_next;

TYPE
  Exc_decl_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Exc_decl;
  OVERRIDES
    next := Exc_decl_next;
  END;

PROCEDURE Var_decl_next(iter: Var_decl_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  VAR
    node0: M3AST_AS.Var_id;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_Var_id.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 1 => 
          r := iter.n.as_type;
          EXIT;

      | 2 => 
          r := iter.n.as_default;
          EXIT;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Var_decl_next;

TYPE
  Var_decl_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Var_decl;
    iter0: SeqM3AST_AS_Var_id.Iter;
  OVERRIDES
    next := Var_decl_next;
  END;

PROCEDURE Const_decl_next(iter: Const_decl_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_id;

    | 1 => 
        r := iter.n.as_type;

    | 2 => 
        r := iter.n.as_exp;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Const_decl_next;

TYPE
  Const_decl_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Const_decl;
  OVERRIDES
    next := Const_decl_next;
  END;

PROCEDURE Proc_decl_next(iter: Proc_decl_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_id;

    | 1 => 
        r := iter.n.as_type;

    | 2 => 
        r := iter.n.as_body;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Proc_decl_next;

TYPE
  Proc_decl_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Proc_decl;
  OVERRIDES
    next := Proc_decl_next;
  END;

PROCEDURE Exc_decl_s_next(iter: Exc_decl_s_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  VAR
    node0: M3AST_AS.Exc_decl;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_Exc_decl.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Exc_decl_s_next;

TYPE
  Exc_decl_s_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Exc_decl_s;
    iter0: SeqM3AST_AS_Exc_decl.Iter;
  OVERRIDES
    next := Exc_decl_s_next;
  END;

PROCEDURE Var_decl_s_next(iter: Var_decl_s_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  VAR
    node0: M3AST_AS.Var_decl;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_Var_decl.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Var_decl_s_next;

TYPE
  Var_decl_s_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Var_decl_s;
    iter0: SeqM3AST_AS_Var_decl.Iter;
  OVERRIDES
    next := Var_decl_s_next;
  END;

PROCEDURE Type_decl_s_next(iter: Type_decl_s_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.TYPE_DECL;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_TYPE_DECL.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Type_decl_s_next;

TYPE
  Type_decl_s_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Type_decl_s;
    iter0: SeqM3AST_AS_TYPE_DECL.Iter;
  OVERRIDES
    next := Type_decl_s_next;
  END;

PROCEDURE Const_decl_s_next(iter: Const_decl_s_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.Const_decl;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_Const_decl.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Const_decl_s_next;

TYPE
  Const_decl_s_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Const_decl_s;
    iter0: SeqM3AST_AS_Const_decl.Iter;
  OVERRIDES
    next := Const_decl_s_next;
  END;

PROCEDURE Revelation_s_next(iter: Revelation_s_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.REVELATION;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_REVELATION.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Revelation_s_next;

TYPE
  Revelation_s_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Revelation_s;
    iter0: SeqM3AST_AS_REVELATION.Iter;
  OVERRIDES
    next := Revelation_s_next;
  END;

PROCEDURE From_import_next(iter: From_import_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.Used_def_id;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          r := iter.n.as_intf_id;
          EXIT;

      | 1 => 
          IF SeqM3AST_AS_Used_def_id.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END From_import_next;

TYPE
  From_import_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.From_import;
    iter0: SeqM3AST_AS_Used_def_id.Iter;
  OVERRIDES
    next := From_import_next;
  END;

PROCEDURE Simple_import_next(iter: Simple_import_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.Import_item;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF SeqM3AST_AS_Import_item.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Simple_import_next;

TYPE
  Simple_import_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Simple_import;
    iter0: SeqM3AST_AS_Import_item.Iter;
  OVERRIDES
    next := Simple_import_next;
  END;


PROCEDURE Import_item_next(iter: Import_item_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_intf_id;

    | 1 => 
        r := iter.n.as_id;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Import_item_next;

TYPE
  Import_item_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Import_item;
  OVERRIDES
    next := Import_item_next;
  END;


PROCEDURE Module_next(iter: Module_iter; VAR r: AST.NODE): BOOLEAN RAISES {
    }=
  VAR
    node0: M3AST_AS.Used_interface_id;
    node1: M3AST_AS.IMPORTED;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          r := iter.n.as_unsafe;
          EXIT;

      | 1 => 
          r := iter.n.as_id;
          EXIT;

      | 2 => 
          IF SeqM3AST_AS_Used_interface_id.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 3 => 
          IF SeqM3AST_AS_IMPORTED.Next(iter.iter1, node1) THEN
            r := node1;
            RETURN TRUE;
          END;

      | 4 => 
          r := iter.n.as_block;
          EXIT;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Module_next;

TYPE
  Module_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Module;
    iter0: SeqM3AST_AS_Used_interface_id.Iter;
    iter1: SeqM3AST_AS_IMPORTED.Iter;
  OVERRIDES
    next := Module_next;
  END;

PROCEDURE Module_gen_def_next(iter: Module_gen_def_iter;
    VAR r: AST.NODE): BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.F_Interface_id;
    node1: M3AST_AS.IMPORTED;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          r := iter.n.as_id;
          EXIT;

      | 1 =>
          IF SeqM3AST_AS_F_Interface_id.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 2 => 
          IF SeqM3AST_AS_IMPORTED.Next(iter.iter1, node1) THEN
            r := node1;
            RETURN TRUE;
          END;

      | 3 => 
          r := iter.n.as_block;
          EXIT;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Module_gen_def_next;

TYPE
  Module_gen_def_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Module_gen_def;
    iter0: SeqM3AST_AS_F_Interface_id.Iter;
    iter1: SeqM3AST_AS_IMPORTED.Iter;
  OVERRIDES
    next := Module_gen_def_next;
  END;

PROCEDURE Module_gen_ins_next(iter: Module_gen_ins_iter;
    VAR r: AST.NODE): BOOLEAN RAISES {}=
  VAR
    node0: M3AST_AS.Used_interface_id;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          r := iter.n.as_unsafe;
          EXIT;

      | 1 => 
          r := iter.n.as_id;
          EXIT;

      | 2 => 
          IF SeqM3AST_AS_Used_interface_id.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 3 => 
          r := iter.n.as_gen_id;
          EXIT;

      | 4 => 
          IF SeqM3AST_AS_Used_interface_id.Next(iter.iter1, node0) THEN
            r := node0;
            RETURN TRUE;
          END;
      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Module_gen_ins_next;

TYPE
  Module_gen_ins_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Module_gen_ins;
    iter0: SeqM3AST_AS_Used_interface_id.Iter;
    iter1: SeqM3AST_AS_Used_interface_id.Iter;
  OVERRIDES
    next := Module_gen_ins_next;
  END;

PROCEDURE Interface_next(iter: Interface_iter; VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  VAR
    node0: M3AST_AS.IMPORTED;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          r := iter.n.as_unsafe;
          EXIT;

      | 1 => 
          r := iter.n.as_id;
          EXIT;

      | 2 => 
          IF SeqM3AST_AS_IMPORTED.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 3 => 
          r := iter.n.as_block;
          EXIT;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Interface_next;

TYPE
  Interface_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Interface;
    iter0: SeqM3AST_AS_IMPORTED.Iter;
  OVERRIDES
    next := Interface_next;
  END;

PROCEDURE Interface_gen_def_next(iter: Interface_gen_def_iter; 
    VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  VAR
    node0: M3AST_AS.F_Interface_id;
    node1: M3AST_AS.IMPORTED;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          r := iter.n.as_id;
          EXIT;

      | 1 =>
          IF SeqM3AST_AS_F_Interface_id.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      | 2 => 
          IF SeqM3AST_AS_IMPORTED.Next(iter.iter1, node1) THEN
            r := node1;
            RETURN TRUE;
          END;

      | 3 => 
          r := iter.n.as_block;
          EXIT;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Interface_gen_def_next;

TYPE
  Interface_gen_def_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Interface_gen_def;
    iter0: SeqM3AST_AS_F_Interface_id.Iter;
    iter1: SeqM3AST_AS_IMPORTED.Iter;
  OVERRIDES
    next := Interface_gen_def_next;
  END;

PROCEDURE Interface_gen_ins_next(iter: Interface_gen_ins_iter; 
    VAR r: AST.NODE): BOOLEAN
    RAISES {}=
  VAR
    node0: M3AST_AS.Used_interface_id;
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          r := iter.n.as_unsafe;
          EXIT;

      | 1 => 
          r := iter.n.as_id;
          EXIT;

      | 2 => 
          r := iter.n.as_gen_id;
          EXIT;

      | 3 => 
          IF SeqM3AST_AS_Used_interface_id.Next(iter.iter0, node0) THEN
            r := node0;
            RETURN TRUE;
          END;

      ELSE
        RETURN FALSE;
      END;
      INC(iter.slot);
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Interface_gen_ins_next;

TYPE
  Interface_gen_ins_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Interface_gen_ins;
    iter0: SeqM3AST_AS_Used_interface_id.Iter;
  OVERRIDES
    next := Interface_gen_ins_next;
  END;

PROCEDURE Compilation_Unit_next(iter: Compilation_Unit_iter; 
    VAR r: AST.NODE): BOOLEAN RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_root;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Compilation_Unit_next;

TYPE
  Compilation_Unit_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Compilation_Unit;
  OVERRIDES
    next := Compilation_Unit_next;
  END;

PROCEDURE Qual_used_id_next(iter: Qual_used_id_iter; VAR r: AST.NODE): 
    BOOLEAN RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        r := iter.n.as_intf_id;

    | 1 => 
        r := iter.n.as_id;

    ELSE
      RETURN FALSE;
    END;
    INC(iter.slot);
    RETURN TRUE;
  END Qual_used_id_next;

TYPE
  Qual_used_id_iter = AST_Iter.T OBJECT
    n: M3AST_AS_F.Qual_used_id;
  OVERRIDES
    next := Qual_used_id_next;
  END;

PROCEDURE Qual_used_id_newIter(n: M3AST_AS_F.Qual_used_id): AST_Iter.T
    RAISES {}=
  BEGIN
    RETURN NEW(Qual_used_id_iter, n := n);
  END Qual_used_id_newIter;


PROCEDURE Compilation_Unit_newIter(n: M3AST_AS_F.Compilation_Unit): AST_Iter.
    T RAISES {}=
  BEGIN
    RETURN NEW(Compilation_Unit_iter, n := n);
  END Compilation_Unit_newIter;


PROCEDURE Interface_newIter(n: M3AST_AS_F.Interface): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Interface_iter, n := n, iter0 := SeqM3AST_AS_IMPORTED.NewIter(
        n.as_import_s));
  END Interface_newIter;


PROCEDURE Interface_gen_def_newIter(n: M3AST_AS_F.Interface_gen_def): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Interface_gen_def_iter, n := n,
        iter0 := SeqM3AST_AS_F_Interface_id.NewIter(n.as_id_s),
        iter1 := SeqM3AST_AS_IMPORTED.NewIter(
        n.as_import_s));
  END Interface_gen_def_newIter;


PROCEDURE Interface_gen_ins_newIter(n: M3AST_AS_F.Interface_gen_ins): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Interface_gen_ins_iter, n := n,
        iter0 := SeqM3AST_AS_Used_interface_id.NewIter(n.as_id_s));
  END Interface_gen_ins_newIter;


PROCEDURE Module_newIter(n: M3AST_AS_F.Module): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Module_iter, n := n, iter0 := SeqM3AST_AS_Used_interface_id.
        NewIter(n.as_export_s), iter1 := SeqM3AST_AS_IMPORTED.NewIter(n.
        as_import_s));
  END Module_newIter;


PROCEDURE Module_gen_def_newIter(n: M3AST_AS_F.Module_gen_def): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Module_gen_def_iter, n := n,
        iter0 := SeqM3AST_AS_F_Interface_id.NewIter(n.as_id_s),
        iter1 := SeqM3AST_AS_IMPORTED.NewIter(n.as_import_s));
  END Module_gen_def_newIter;


PROCEDURE Module_gen_ins_newIter(n: M3AST_AS_F.Module_gen_ins): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Module_gen_ins_iter, n := n,
        iter0 := SeqM3AST_AS_Used_interface_id.NewIter(n.as_export_s),
        iter1 := SeqM3AST_AS_Used_interface_id.NewIter(n.as_id_s));
  END Module_gen_ins_newIter;


PROCEDURE Simple_import_newIter(n: M3AST_AS_F.Simple_import): AST_Iter.T
    RAISES {}=
  BEGIN
    RETURN NEW(Simple_import_iter, n := n, iter0 := 
        SeqM3AST_AS_Import_item.NewIter(n.as_import_item_s));
  END Simple_import_newIter;


PROCEDURE Import_item_newIter(n: M3AST_AS_F.Import_item): AST_Iter.T
    RAISES {}=
  BEGIN
    RETURN NEW(Import_item_iter, n := n);
  END Import_item_newIter;


PROCEDURE From_import_newIter(n: M3AST_AS_F.From_import): AST_Iter.T RAISES {
    }=
  BEGIN
    RETURN NEW(From_import_iter, n := n, iter0 := SeqM3AST_AS_Used_def_id.
        NewIter(n.as_id_s));
  END From_import_newIter;


PROCEDURE Revelation_s_newIter(n: M3AST_AS_F.Revelation_s): AST_Iter.T
    RAISES {}=
  BEGIN
    RETURN NEW(Revelation_s_iter, n := n, iter0 := SeqM3AST_AS_REVELATION.
        NewIter(n.as_reveal_s));
  END Revelation_s_newIter;


PROCEDURE Const_decl_s_newIter(n: M3AST_AS_F.Const_decl_s): AST_Iter.T
    RAISES {}=
  BEGIN
    RETURN NEW(Const_decl_s_iter, n := n, iter0 := SeqM3AST_AS_Const_decl.
        NewIter(n.as_const_decl_s));
  END Const_decl_s_newIter;


PROCEDURE Type_decl_s_newIter(n: M3AST_AS_F.Type_decl_s): AST_Iter.T RAISES {
    }=
  BEGIN
    RETURN NEW(Type_decl_s_iter, n := n, iter0 := SeqM3AST_AS_TYPE_DECL.
        NewIter(n.as_type_decl_s));
  END Type_decl_s_newIter;


PROCEDURE Var_decl_s_newIter(n: M3AST_AS_F.Var_decl_s): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Var_decl_s_iter, n := n, iter0 := SeqM3AST_AS_Var_decl.NewIter
        (n.as_var_decl_s));
  END Var_decl_s_newIter;


PROCEDURE Exc_decl_s_newIter(n: M3AST_AS_F.Exc_decl_s): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Exc_decl_s_iter, n := n, iter0 := SeqM3AST_AS_Exc_decl.NewIter
        (n.as_exc_decl_s));
  END Exc_decl_s_newIter;


PROCEDURE Proc_decl_newIter(n: M3AST_AS_F.Proc_decl): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Proc_decl_iter, n := n);
  END Proc_decl_newIter;


PROCEDURE Const_decl_newIter(n: M3AST_AS_F.Const_decl): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Const_decl_iter, n := n);
  END Const_decl_newIter;


PROCEDURE Var_decl_newIter(n: M3AST_AS_F.Var_decl): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Var_decl_iter, n := n, iter0 := SeqM3AST_AS_Var_id.NewIter(n.
        as_id_s));
  END Var_decl_newIter;


PROCEDURE Exc_decl_newIter(n: M3AST_AS_F.Exc_decl): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Exc_decl_iter, n := n);
  END Exc_decl_newIter;


PROCEDURE Subtype_decl_newIter(n: M3AST_AS_F.Subtype_decl): AST_Iter.T
    RAISES {}=
  BEGIN
    RETURN NEW(Subtype_decl_iter, n := n);
  END Subtype_decl_newIter;


PROCEDURE Concrete_decl_newIter(n: M3AST_AS_F.Concrete_decl): AST_Iter.T
    RAISES {}=
  BEGIN
    RETURN NEW(Concrete_decl_iter, n := n);
  END Concrete_decl_newIter;


PROCEDURE Subtype_reveal_newIter(n: M3AST_AS_F.Subtype_reveal): AST_Iter.T
    RAISES {}=
  BEGIN
    RETURN NEW(Subtype_reveal_iter, n := n);
  END Subtype_reveal_newIter;


PROCEDURE Concrete_reveal_newIter(n: M3AST_AS_F.Concrete_reveal): AST_Iter.T
    RAISES {}=
  BEGIN
    RETURN NEW(Concrete_reveal_iter, n := n);
  END Concrete_reveal_newIter;


PROCEDURE Named_type_newIter(n: M3AST_AS_F.Named_type): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Named_type_iter, n := n);
  END Named_type_newIter;


PROCEDURE Root_type_newIter(n: M3AST_AS_F.Root_type): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Root_type_iter, n := n);
  END Root_type_newIter;


PROCEDURE Enumeration_type_newIter(n: M3AST_AS_F.Enumeration_type): AST_Iter.
    T RAISES {}=
  BEGIN
    RETURN NEW(Enumeration_type_iter, n := n, iter0 := SeqM3AST_AS_Enum_id.
        NewIter(n.as_id_s));
  END Enumeration_type_newIter;


PROCEDURE Subrange_type_newIter(n: M3AST_AS_F.Subrange_type): AST_Iter.T
    RAISES {}=
  BEGIN
    RETURN NEW(Subrange_type_iter, n := n);
  END Subrange_type_newIter;


PROCEDURE Array_type_newIter(n: M3AST_AS_F.Array_type): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Array_type_iter, n := n, iter0 := SeqM3AST_AS_M3TYPE.NewIter(n
        .as_indextype_s));
  END Array_type_newIter;


PROCEDURE Record_type_newIter(n: M3AST_AS_F.Record_type): AST_Iter.T RAISES {
    }=
  BEGIN
    RETURN NEW(Record_type_iter, n := n, iter0 := SeqM3AST_AS_Fields.NewIter(
        n.as_fields_s));
  END Record_type_newIter;


PROCEDURE Object_type_newIter(n: M3AST_AS_F.Object_type): AST_Iter.T RAISES {
    }=
  BEGIN
    RETURN NEW(Object_type_iter, n := n, iter0 := SeqM3AST_AS_Fields.NewIter(
        n.as_fields_s), iter1 := SeqM3AST_AS_Method.NewIter(n.as_method_s),
        iter2 := SeqM3AST_AS_Override.NewIter(n.as_override_s));
  END Object_type_newIter;


PROCEDURE Set_type_newIter(n: M3AST_AS_F.Set_type): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Set_type_iter, n := n);
  END Set_type_newIter;


PROCEDURE Procedure_type_newIter(n: M3AST_AS_F.Procedure_type): AST_Iter.T
    RAISES {}=
  BEGIN
    RETURN NEW(Procedure_type_iter, n := n, iter0 := SeqM3AST_AS_Formal_param
        .NewIter(n.as_formal_param_s));
  END Procedure_type_newIter;


PROCEDURE Ref_type_newIter(n: M3AST_AS_F.Ref_type): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Ref_type_iter, n := n);
  END Ref_type_newIter;


PROCEDURE Packed_type_newIter(n: M3AST_AS_F.Packed_type): AST_Iter.T RAISES {
    }=
  BEGIN
    RETURN NEW(Packed_type_iter, n := n);
  END Packed_type_newIter;


PROCEDURE Opaque_type_newIter(n: M3AST_AS_F.Opaque_type): AST_Iter.T RAISES {
    }=
  BEGIN
    RETURN NEW(Opaque_type_iter, n := n);
  END Opaque_type_newIter;


PROCEDURE Brand_newIter(n: M3AST_AS_F.Brand): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Brand_iter, n := n);
  END Brand_newIter;


PROCEDURE Fields_newIter(n: M3AST_AS_F.Fields): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Fields_iter, n := n, iter0 := SeqM3AST_AS_Field_id.NewIter(n.
        as_id_s));
  END Fields_newIter;


PROCEDURE Method_newIter(n: M3AST_AS_F.Method): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Method_iter, n := n);
  END Method_newIter;


PROCEDURE Override_newIter(n: M3AST_AS_F.Override): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Override_iter, n := n);
  END Override_newIter;


PROCEDURE Formal_param_newIter(n: M3AST_AS_F.Formal_param): AST_Iter.T
    RAISES {}=
  BEGIN
    RETURN NEW(Formal_param_iter, n := n, iter0 := SeqM3AST_AS_FORMAL_ID.
        NewIter(n.as_id_s));
  END Formal_param_newIter;


PROCEDURE Raisees_some_newIter(n: M3AST_AS_F.Raisees_some): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Raisees_some_iter, n := n, iter0 := SeqM3AST_AS_Qual_used_id.
        NewIter(n.as_raisees_s));
  END Raisees_some_newIter;


PROCEDURE Range_EXP_newIter(n: M3AST_AS_F.Range_EXP): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Range_EXP_iter, n := n);
  END Range_EXP_newIter;


PROCEDURE Range_newIter(n: M3AST_AS_F.Range): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Range_iter, n := n);
  END Range_newIter;


PROCEDURE Constructor_newIter(n: M3AST_AS_F.Constructor): AST_Iter.T RAISES {
    }=
  BEGIN
    RETURN NEW(Constructor_iter, n := n, iter0 := SeqM3AST_AS_CONS_ELEM.
        NewIter(n.as_element_s));
  END Constructor_newIter;


PROCEDURE RANGE_EXP_elem_newIter(n: M3AST_AS_F.RANGE_EXP_elem): AST_Iter.T
    RAISES {}=
  BEGIN
    RETURN NEW(RANGE_EXP_elem_iter, n := n);
  END RANGE_EXP_elem_newIter;


PROCEDURE Actual_elem_newIter(n: M3AST_AS_F.Actual_elem): AST_Iter.T RAISES {
    }=
  BEGIN
    RETURN NEW(Actual_elem_iter, n := n);
  END Actual_elem_newIter;


PROCEDURE Propagate_newIter(n: M3AST_AS_F.Propagate): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Propagate_iter, n := n);
  END Propagate_newIter;


PROCEDURE Binary_newIter(n: M3AST_AS_F.Binary): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Binary_iter, n := n);
  END Binary_newIter;


PROCEDURE Unary_newIter(n: M3AST_AS_F.Unary): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Unary_iter, n := n);
  END Unary_newIter;


PROCEDURE Call_newIter(n: M3AST_AS_F.Call): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Call_iter, n := n, iter0 := SeqM3AST_AS_Actual.NewIter(n.
        as_param_s));
  END Call_newIter;


PROCEDURE Index_newIter(n: M3AST_AS_F.Index): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Index_iter, n := n, iter0 := SeqM3AST_AS_EXP.NewIter(n.
        as_exp_s));
  END Index_newIter;


PROCEDURE Actual_newIter(n: M3AST_AS_F.Actual): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Actual_iter, n := n);
  END Actual_newIter;


PROCEDURE Assign_st_newIter(n: M3AST_AS_F.Assign_st): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Assign_st_iter, n := n);
  END Assign_st_newIter;


PROCEDURE Call_st_newIter(n: M3AST_AS_F.Call_st): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Call_st_iter, n := n);
  END Call_st_newIter;


PROCEDURE Case_st_newIter(n: M3AST_AS_F.Case_st): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Case_st_iter, n := n, iter0 := SeqM3AST_AS_Case.NewIter(n.
        as_case_s));
  END Case_st_newIter;


PROCEDURE Eval_st_newIter(n: M3AST_AS_F.Eval_st): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Eval_st_iter, n := n);
  END Eval_st_newIter;


PROCEDURE Exit_st_newIter(n: M3AST_AS_F.Exit_st): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Exit_st_iter, n := n);
  END Exit_st_newIter;


PROCEDURE For_st_newIter(n: M3AST_AS_F.For_st): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(For_st_iter, n := n, iter0 := SeqM3AST_AS_STM.NewIter(n.
        as_stm_s));
  END For_st_newIter;


PROCEDURE If_st_newIter(n: M3AST_AS_F.If_st): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(If_st_iter, n := n, iter0 := SeqM3AST_AS_STM.NewIter(n.
        as_stm_s), iter1 := SeqM3AST_AS_Elsif.NewIter(n.as_elsif_s));
  END If_st_newIter;


PROCEDURE Lock_st_newIter(n: M3AST_AS_F.Lock_st): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Lock_st_iter, n := n, iter0 := SeqM3AST_AS_STM.NewIter(n.
        as_stm_s));
  END Lock_st_newIter;


PROCEDURE Loop_st_newIter(n: M3AST_AS_F.Loop_st): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Loop_st_iter, n := n, iter0 := SeqM3AST_AS_STM.NewIter(n.
        as_stm_s));
  END Loop_st_newIter;


PROCEDURE Raise_st_newIter(n: M3AST_AS_F.Raise_st): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Raise_st_iter, n := n);
  END Raise_st_newIter;


PROCEDURE Repeat_st_newIter(n: M3AST_AS_F.Repeat_st): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Repeat_st_iter, n := n, iter0 := SeqM3AST_AS_STM.NewIter(n.
        as_stm_s));
  END Repeat_st_newIter;


PROCEDURE Return_st_newIter(n: M3AST_AS_F.Return_st): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Return_st_iter, n := n);
  END Return_st_newIter;


PROCEDURE Try_st_newIter(n: M3AST_AS_F.Try_st): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Try_st_iter, n := n, iter0 := SeqM3AST_AS_STM.NewIter(n.
        as_stm_s));
  END Try_st_newIter;


PROCEDURE Typecase_st_newIter(n: M3AST_AS_F.Typecase_st): AST_Iter.T RAISES {
    }=
  BEGIN
    RETURN NEW(Typecase_st_iter, n := n, iter0 := SeqM3AST_AS_Tcase.NewIter(n
        .as_tcase_s));
  END Typecase_st_newIter;


PROCEDURE While_st_newIter(n: M3AST_AS_F.While_st): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(While_st_iter, n := n, iter0 := SeqM3AST_AS_STM.NewIter(n.
        as_stm_s));
  END While_st_newIter;


PROCEDURE With_st_newIter(n: M3AST_AS_F.With_st): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(With_st_iter, n := n, iter0 := SeqM3AST_AS_Binding.NewIter(n.
        as_binding_s), iter1 := SeqM3AST_AS_STM.NewIter(n.as_stm_s));
  END With_st_newIter;


PROCEDURE Block_newIter(n: M3AST_AS_F.Block): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Block_iter, n := n, iter0 := SeqM3AST_AS_DECL_REVL.NewIter(n.
        as_decl_s), iter1 := SeqM3AST_AS_STM.NewIter(n.as_stm_s));
  END Block_newIter;


PROCEDURE Case_newIter(n: M3AST_AS_F.Case): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Case_iter, n := n, iter0 := SeqM3AST_AS_RANGE_EXP.NewIter(n.
        as_case_label_s), iter1 := SeqM3AST_AS_STM.NewIter(n.as_stm_s));
  END Case_newIter;


PROCEDURE Else_stm_newIter(n: M3AST_AS_F.Else_stm): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Else_stm_iter, n := n, iter0 := SeqM3AST_AS_STM.NewIter(n.
        as_stm_s));
  END Else_stm_newIter;


PROCEDURE Elsif_newIter(n: M3AST_AS_F.Elsif): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Elsif_iter, n := n, iter0 := SeqM3AST_AS_STM.NewIter(n.
        as_stm_s));
  END Elsif_newIter;


PROCEDURE Try_except_newIter(n: M3AST_AS_F.Try_except): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Try_except_iter, n := n, iter0 := SeqM3AST_AS_Handler.NewIter(
        n.as_handler_s), iter1 := SeqM3AST_AS_STM.NewIter(n.as_stm_s));
  END Try_except_newIter;


PROCEDURE Try_finally_newIter(n: M3AST_AS_F.Try_finally): AST_Iter.T RAISES {
    }=
  BEGIN
    RETURN NEW(Try_finally_iter, n := n, iter0 := SeqM3AST_AS_STM.NewIter(n.
        as_stm_s));
  END Try_finally_newIter;


PROCEDURE Tcase_newIter(n: M3AST_AS_F.Tcase): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Tcase_iter, n := n, iter0 := SeqM3AST_AS_M3TYPE.NewIter(n.
        as_type_s), iter1 := SeqM3AST_AS_STM.NewIter(n.as_stm_s));
  END Tcase_newIter;


PROCEDURE Handler_newIter(n: M3AST_AS_F.Handler): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Handler_iter, n := n, iter0 := SeqM3AST_AS_Qual_used_id.
        NewIter(n.as_qual_id_s), iter1 := SeqM3AST_AS_STM.NewIter(n.as_stm_s)
        );
  END Handler_newIter;


PROCEDURE Binding_newIter(n: M3AST_AS_F.Binding): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(Binding_iter, n := n);
  END Binding_newIter;


PROCEDURE By_newIter(n: M3AST_AS_F.By): AST_Iter.T RAISES {}=
  BEGIN
    RETURN NEW(By_iter, n := n);
  END By_newIter;


PROCEDURE Qual_used_id_update(n: M3AST_AS_F.Qual_used_id; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_intf_id := nn;

    | 1 => 
        n.as_id := nn;

    END;
  END Qual_used_id_update;


PROCEDURE Compilation_Unit_update(n: M3AST_AS_F.Compilation_Unit; 
    iter: AST_Iter.T; nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_root := nn;

    END;
  END Compilation_Unit_update;


PROCEDURE Interface_update(n: M3AST_AS_F.Interface; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Interface_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          n.as_unsafe := nn;
          RETURN ;

      | 1 => 
          n.as_id := nn;
          RETURN ;

      | 2 => 
          IF NOT SeqM3AST_AS_IMPORTED.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_IMPORTED.Update(n.as_import_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      | 3 => 
          n.as_block := nn;
          RETURN ;

      END;
      INC(iter.slot);
    END;
  END Interface_update;


PROCEDURE Interface_gen_def_update(n: M3AST_AS_F.Interface_gen_def;
    iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Interface_gen_def_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          n.as_id := nn;
          RETURN ;

      | 1 => 
          IF NOT SeqM3AST_AS_F_Interface_id.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_F_Interface_id.Update(n.as_id_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      | 2 => 
          IF NOT SeqM3AST_AS_IMPORTED.Exhausted(narrow_iter.iter1) THEN
            SeqM3AST_AS_IMPORTED.Update(n.as_import_s, narrow_iter.iter1, nn);
            RETURN ;
          END;

      | 3 => 
          n.as_block := nn;
          RETURN ;

      END;
      INC(iter.slot);
    END;
  END Interface_gen_def_update;


PROCEDURE Interface_gen_ins_update(n: M3AST_AS_F.Interface_gen_ins;
    iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Interface_gen_ins_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          n.as_unsafe := nn;
          RETURN;

      | 1 => 
          n.as_id := nn;
          RETURN ;

      | 2 => 
          n.as_gen_id := nn;
          RETURN ;

      | 3 => 
          IF NOT SeqM3AST_AS_Used_interface_id.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_Used_interface_id.Update(n.as_id_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Interface_gen_ins_update;


PROCEDURE Module_gen_def_update(n: M3AST_AS_F.Module_gen_def;
    iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Module_gen_def_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          n.as_id := nn;
          RETURN ;

      | 1 => 
          IF NOT SeqM3AST_AS_F_Interface_id.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_F_Interface_id.Update(n.as_id_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      | 2 => 
          IF NOT SeqM3AST_AS_IMPORTED.Exhausted(narrow_iter.iter1) THEN
            SeqM3AST_AS_IMPORTED.Update(n.as_import_s, narrow_iter.iter1, nn);
            RETURN ;
          END;

      | 3 => 
          n.as_block := nn;
          RETURN ;

      END;
      INC(iter.slot);
    END;
  END Module_gen_def_update;


PROCEDURE Module_gen_ins_update(n: M3AST_AS_F.Module_gen_ins;
    iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Module_gen_ins_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          n.as_unsafe := nn;
          RETURN;

      | 1 => 
          n.as_id := nn;
          RETURN ;

      | 2 => 
          IF NOT SeqM3AST_AS_Used_interface_id.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_Used_interface_id.Update(n.as_id_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      | 3 => 
          n.as_gen_id := nn;
          RETURN ;

      | 4 => 
          IF NOT SeqM3AST_AS_Used_interface_id.Exhausted(narrow_iter.iter1) THEN
            SeqM3AST_AS_Used_interface_id.Update(n.as_id_s, narrow_iter.iter1, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Module_gen_ins_update;


PROCEDURE Module_update(n: M3AST_AS_F.Module; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Module_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          n.as_unsafe := nn;
          RETURN ;

      | 1 => 
          n.as_id := nn;
          RETURN ;

      | 2 => 
          IF NOT SeqM3AST_AS_Used_interface_id.Exhausted(narrow_iter.iter0)
              THEN
            SeqM3AST_AS_Used_interface_id.Update(n.as_export_s, narrow_iter.
                iter0, nn);
            RETURN ;
          END;

      | 3 => 
          IF NOT SeqM3AST_AS_IMPORTED.Exhausted(narrow_iter.iter1) THEN
            SeqM3AST_AS_IMPORTED.Update(n.as_import_s, narrow_iter.iter1, nn);
            RETURN ;
          END;

      | 4 => 
          n.as_block := nn;
          RETURN ;

      END;
      INC(iter.slot);
    END;
  END Module_update;


PROCEDURE Simple_import_update(n: M3AST_AS_F.Simple_import; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Simple_import_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_Import_item.Exhausted(narrow_iter.iter0)
              THEN
            SeqM3AST_AS_Import_item.Update(n.as_import_item_s, narrow_iter.iter0, 
                nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Simple_import_update;


PROCEDURE From_import_update(n: M3AST_AS_F.From_import; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, From_import_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          n.as_intf_id := nn;
          RETURN ;

      | 1 => 
          IF NOT SeqM3AST_AS_Used_def_id.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_Used_def_id.Update(n.as_id_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END From_import_update;


PROCEDURE Import_item_update(n: M3AST_AS_F.Import_item; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_intf_id := nn;

    | 1 => 
        n.as_id := nn;

    END;
  END Import_item_update;


PROCEDURE Revelation_s_update(n: M3AST_AS_F.Revelation_s; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Revelation_s_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_REVELATION.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_REVELATION.Update(n.as_reveal_s, narrow_iter.iter0, 
                nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Revelation_s_update;


PROCEDURE Const_decl_s_update(n: M3AST_AS_F.Const_decl_s; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Const_decl_s_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_Const_decl.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_Const_decl.Update(n.as_const_decl_s, narrow_iter.
                iter0, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Const_decl_s_update;


PROCEDURE Type_decl_s_update(n: M3AST_AS_F.Type_decl_s; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Type_decl_s_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_TYPE_DECL.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_TYPE_DECL.Update(n.as_type_decl_s, narrow_iter.iter0, 
                nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Type_decl_s_update;


PROCEDURE Var_decl_s_update(n: M3AST_AS_F.Var_decl_s; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Var_decl_s_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_Var_decl.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_Var_decl.Update(n.as_var_decl_s, narrow_iter.iter0, 
                nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Var_decl_s_update;


PROCEDURE Exc_decl_s_update(n: M3AST_AS_F.Exc_decl_s; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Exc_decl_s_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_Exc_decl.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_Exc_decl.Update(n.as_exc_decl_s, narrow_iter.iter0, 
                nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Exc_decl_s_update;


PROCEDURE Proc_decl_update(n: M3AST_AS_F.Proc_decl; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_id := nn;

    | 1 => 
        n.as_type := nn;

    | 2 => 
        n.as_body := nn;

    END;
  END Proc_decl_update;


PROCEDURE Const_decl_update(n: M3AST_AS_F.Const_decl; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_id := nn;

    | 1 => 
        n.as_type := nn;

    | 2 => 
        n.as_exp := nn;

    END;
  END Const_decl_update;


PROCEDURE Var_decl_update(n: M3AST_AS_F.Var_decl; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Var_decl_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_Var_id.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_Var_id.Update(n.as_id_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      | 1 => 
          n.as_type := nn;
          RETURN ;

      | 2 => 
          n.as_default := nn;
          RETURN ;

      END;
      INC(iter.slot);
    END;
  END Var_decl_update;


PROCEDURE Exc_decl_update(n: M3AST_AS_F.Exc_decl; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_id := nn;

    | 1 => 
        n.as_type := nn;

    END;
  END Exc_decl_update;


PROCEDURE Subtype_decl_update(n: M3AST_AS_F.Subtype_decl; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_id := nn;

    | 1 => 
        n.as_type := nn;

    END;
  END Subtype_decl_update;


PROCEDURE Concrete_decl_update(n: M3AST_AS_F.Concrete_decl; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_id := nn;

    | 1 => 
        n.as_type := nn;

    END;
  END Concrete_decl_update;


PROCEDURE Subtype_reveal_update(n: M3AST_AS_F.Subtype_reveal; 
    iter: AST_Iter.T; nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_qual_id := nn;

    | 1 => 
        n.as_type := nn;

    END;
  END Subtype_reveal_update;


PROCEDURE Concrete_reveal_update(n: M3AST_AS_F.Concrete_reveal; 
    iter: AST_Iter.T; nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_qual_id := nn;

    | 1 => 
        n.as_type := nn;

    END;
  END Concrete_reveal_update;


PROCEDURE Named_type_update(n: M3AST_AS_F.Named_type; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_qual_id := nn;

    END;
  END Named_type_update;


PROCEDURE Root_type_update(n: M3AST_AS_F.Root_type; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_trace_mode := nn;

    END;
  END Root_type_update;


PROCEDURE Enumeration_type_update(n: M3AST_AS_F.Enumeration_type; 
    iter: AST_Iter.T; nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Enumeration_type_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_Enum_id.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_Enum_id.Update(n.as_id_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Enumeration_type_update;


PROCEDURE Subrange_type_update(n: M3AST_AS_F.Subrange_type; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_range := nn;

    END;
  END Subrange_type_update;


PROCEDURE Array_type_update(n: M3AST_AS_F.Array_type; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Array_type_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_M3TYPE.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_M3TYPE.Update(n.as_indextype_s, narrow_iter.iter0, nn
                );
            RETURN ;
          END;

      | 1 => 
          n.as_elementtype := nn;
          RETURN ;

      END;
      INC(iter.slot);
    END;
  END Array_type_update;


PROCEDURE Record_type_update(n: M3AST_AS_F.Record_type; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Record_type_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_Fields.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_Fields.Update(n.as_fields_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Record_type_update;


PROCEDURE Object_type_update(n: M3AST_AS_F.Object_type; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Object_type_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          n.as_ancestor := nn;
          RETURN ;

      | 1 => 
          n.as_brand := nn;
          RETURN ;

      | 2 => 
          IF NOT SeqM3AST_AS_Fields.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_Fields.Update(n.as_fields_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      | 3 => 
          IF NOT SeqM3AST_AS_Method.Exhausted(narrow_iter.iter1) THEN
            SeqM3AST_AS_Method.Update(n.as_method_s, narrow_iter.iter1, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Object_type_update;


PROCEDURE Set_type_update(n: M3AST_AS_F.Set_type; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_type := nn;

    END;
  END Set_type_update;


PROCEDURE Procedure_type_update(n: M3AST_AS_F.Procedure_type; 
    iter: AST_Iter.T; nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Procedure_type_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_Formal_param.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_Formal_param.Update(n.as_formal_param_s, narrow_iter.
                iter0, nn);
            RETURN ;
          END;

      | 1 => 
          n.as_result_type := nn;
          RETURN ;

      | 2 => 
          n.as_raises := nn;
          RETURN ;

      END;
      INC(iter.slot);
    END;
  END Procedure_type_update;


PROCEDURE Ref_type_update(n: M3AST_AS_F.Ref_type; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_trace_mode := nn;

    | 1 => 
        n.as_brand := nn;

    | 2 => 
        n.as_type := nn;

    END;
  END Ref_type_update;


PROCEDURE Packed_type_update(n: M3AST_AS_F.Packed_type; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_exp := nn;

    | 1 => 
        n.as_type := nn;

    END;
  END Packed_type_update;


PROCEDURE Opaque_type_update(n: M3AST_AS_F.Opaque_type; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_type := nn;

    END;
  END Opaque_type_update;


PROCEDURE Brand_update(n: M3AST_AS_F.Brand; iter: AST_Iter.T; nn: AST.NODE)
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_exp := nn;

    END;
  END Brand_update;


PROCEDURE Fields_update(n: M3AST_AS_F.Fields; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Fields_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_Field_id.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_Field_id.Update(n.as_id_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      | 1 => 
          n.as_type := nn;
          RETURN ;

      | 2 => 
          n.as_default := nn;
          RETURN ;

      END;
      INC(iter.slot);
    END;
  END Fields_update;


PROCEDURE Method_update(n: M3AST_AS_F.Method; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_id := nn;

    | 1 => 
        n.as_type := nn;

    | 2 => 
        n.as_default := nn;

    END;
  END Method_update;


PROCEDURE Override_update(n: M3AST_AS_F.Override; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_id := nn;

    | 1 => 
        n.as_default := nn;

    END;
  END Override_update;


PROCEDURE Formal_param_update(n: M3AST_AS_F.Formal_param; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Formal_param_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_FORMAL_ID.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_FORMAL_ID.Update(n.as_id_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      | 1 => 
          n.as_formal_type := nn;
          RETURN ;

      | 2 => 
          n.as_default := nn;
          RETURN ;

      END;
      INC(iter.slot);
    END;
  END Formal_param_update;


PROCEDURE Raisees_some_update(n: M3AST_AS_F.Raisees_some; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Raisees_some_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_Qual_used_id.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_Qual_used_id.Update(n.as_raisees_s, narrow_iter.iter0, 
                nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Raisees_some_update;


PROCEDURE Range_EXP_update(n: M3AST_AS_F.Range_EXP; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_exp := nn;

    END;
  END Range_EXP_update;


PROCEDURE Range_update(n: M3AST_AS_F.Range; iter: AST_Iter.T; nn: AST.NODE)
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_exp1 := nn;

    | 1 => 
        n.as_exp2 := nn;

    END;
  END Range_update;


PROCEDURE Constructor_update(n: M3AST_AS_F.Constructor; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Constructor_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          n.as_type := nn;
          RETURN ;

      | 1 => 
          IF NOT SeqM3AST_AS_CONS_ELEM.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_CONS_ELEM.Update(n.as_element_s, narrow_iter.iter0, 
                nn);
            RETURN ;
          END;

      | 2 => 
          n.as_propagate := nn;
          RETURN ;

      END;
      INC(iter.slot);
    END;
  END Constructor_update;


PROCEDURE RANGE_EXP_elem_update(n: M3AST_AS_F.RANGE_EXP_elem; 
    iter: AST_Iter.T; nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_range_exp := nn;

    END;
  END RANGE_EXP_elem_update;


PROCEDURE Actual_elem_update(n: M3AST_AS_F.Actual_elem; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_actual := nn;

    END;
  END Actual_elem_update;


PROCEDURE Propagate_update(<*UNUSED*> n: M3AST_AS_F.Propagate;
    iter: AST_Iter.T; 
    <*UNUSED*> nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    END;
  END Propagate_update;


PROCEDURE Binary_update(n: M3AST_AS_F.Binary; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_binary_op := nn;

    | 1 => 
        n.as_exp1 := nn;

    | 2 => 
        n.as_exp2 := nn;

    END;
  END Binary_update;


PROCEDURE Unary_update(n: M3AST_AS_F.Unary; iter: AST_Iter.T; nn: AST.NODE)
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_unary_op := nn;

    | 1 => 
        n.as_exp := nn;

    END;
  END Unary_update;


PROCEDURE Call_update(n: M3AST_AS_F.Call; iter: AST_Iter.T; nn: AST.NODE)
    RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Call_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          n.as_callexp := nn;
          RETURN ;

      | 1 => 
          IF NOT SeqM3AST_AS_Actual.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_Actual.Update(n.as_param_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Call_update;


PROCEDURE Index_update(n: M3AST_AS_F.Index; iter: AST_Iter.T; nn: AST.NODE)
    RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Index_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          n.as_array := nn;
          RETURN ;

      | 1 => 
          IF NOT SeqM3AST_AS_EXP.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_EXP.Update(n.as_exp_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Index_update;


PROCEDURE Actual_update(n: M3AST_AS_F.Actual; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_id := nn;

    | 1 => 
        n.as_exp_type := nn;

    END;
  END Actual_update;


PROCEDURE Assign_st_update(n: M3AST_AS_F.Assign_st; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_lhs_exp := nn;

    | 1 => 
        n.as_rhs_exp := nn;

    END;
  END Assign_st_update;


PROCEDURE Call_st_update(n: M3AST_AS_F.Call_st; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_call := nn;

    END;
  END Call_st_update;


PROCEDURE Case_st_update(n: M3AST_AS_F.Case_st; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Case_st_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          n.as_exp := nn;
          RETURN ;

      | 1 => 
          IF NOT SeqM3AST_AS_Case.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_Case.Update(n.as_case_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      | 2 => 
          n.as_else := nn;
          RETURN ;

      END;
      INC(iter.slot);
    END;
  END Case_st_update;


PROCEDURE Eval_st_update(n: M3AST_AS_F.Eval_st; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_exp := nn;

    END;
  END Eval_st_update;


PROCEDURE Exit_st_update(<*UNUSED*> n: M3AST_AS_F.Exit_st; iter: AST_Iter.T; 
    <*UNUSED*> nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    END;
  END Exit_st_update;


PROCEDURE For_st_update(n: M3AST_AS_F.For_st; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, For_st_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          n.as_id := nn;
          RETURN ;

      | 1 => 
          n.as_from := nn;
          RETURN ;

      | 2 => 
          n.as_to := nn;
          RETURN ;

      | 3 => 
          n.as_by := nn;
          RETURN ;

      | 4 => 
          IF NOT SeqM3AST_AS_STM.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_STM.Update(n.as_stm_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END For_st_update;


PROCEDURE If_st_update(n: M3AST_AS_F.If_st; iter: AST_Iter.T; nn: AST.NODE)
    RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, If_st_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          n.as_exp := nn;
          RETURN ;

      | 1 => 
          IF NOT SeqM3AST_AS_STM.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_STM.Update(n.as_stm_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      | 2 => 
          IF NOT SeqM3AST_AS_Elsif.Exhausted(narrow_iter.iter1) THEN
            SeqM3AST_AS_Elsif.Update(n.as_elsif_s, narrow_iter.iter1, nn);
            RETURN ;
          END;

      | 3 => 
          n.as_else := nn;
          RETURN ;

      END;
      INC(iter.slot);
    END;
  END If_st_update;


PROCEDURE Lock_st_update(n: M3AST_AS_F.Lock_st; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Lock_st_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          n.as_exp := nn;
          RETURN ;

      | 1 => 
          IF NOT SeqM3AST_AS_STM.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_STM.Update(n.as_stm_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Lock_st_update;


PROCEDURE Loop_st_update(n: M3AST_AS_F.Loop_st; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Loop_st_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_STM.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_STM.Update(n.as_stm_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Loop_st_update;


PROCEDURE Raise_st_update(n: M3AST_AS_F.Raise_st; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_qual_id := nn;

    | 1 => 
        n.as_exp_void := nn;

    END;
  END Raise_st_update;


PROCEDURE Repeat_st_update(n: M3AST_AS_F.Repeat_st; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Repeat_st_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_STM.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_STM.Update(n.as_stm_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      | 1 => 
          n.as_exp := nn;
          RETURN ;

      END;
      INC(iter.slot);
    END;
  END Repeat_st_update;


PROCEDURE Return_st_update(n: M3AST_AS_F.Return_st; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_exp := nn;

    END;
  END Return_st_update;


PROCEDURE Try_st_update(n: M3AST_AS_F.Try_st; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Try_st_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_STM.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_STM.Update(n.as_stm_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      | 1 => 
          n.as_try_tail := nn;
          RETURN ;

      END;
      INC(iter.slot);
    END;
  END Try_st_update;


PROCEDURE Typecase_st_update(n: M3AST_AS_F.Typecase_st; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Typecase_st_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          n.as_exp := nn;
          RETURN ;

      | 1 => 
          IF NOT SeqM3AST_AS_Tcase.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_Tcase.Update(n.as_tcase_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      | 2 => 
          n.as_else := nn;
          RETURN ;

      END;
      INC(iter.slot);
    END;
  END Typecase_st_update;


PROCEDURE While_st_update(n: M3AST_AS_F.While_st; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, While_st_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          n.as_exp := nn;
          RETURN ;

      | 1 => 
          IF NOT SeqM3AST_AS_STM.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_STM.Update(n.as_stm_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END While_st_update;


PROCEDURE With_st_update(n: M3AST_AS_F.With_st; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, With_st_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_Binding.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_Binding.Update(n.as_binding_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      | 1 => 
          IF NOT SeqM3AST_AS_STM.Exhausted(narrow_iter.iter1) THEN
            SeqM3AST_AS_STM.Update(n.as_stm_s, narrow_iter.iter1, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END With_st_update;


PROCEDURE Block_update(n: M3AST_AS_F.Block; iter: AST_Iter.T; nn: AST.NODE)
    RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Block_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_DECL_REVL.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_DECL_REVL.Update(n.as_decl_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      | 1 => 
          IF NOT SeqM3AST_AS_STM.Exhausted(narrow_iter.iter1) THEN
            SeqM3AST_AS_STM.Update(n.as_stm_s, narrow_iter.iter1, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Block_update;


PROCEDURE Case_update(n: M3AST_AS_F.Case; iter: AST_Iter.T; nn: AST.NODE)
    RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Case_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_RANGE_EXP.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_RANGE_EXP.Update(n.as_case_label_s, narrow_iter.iter0, 
                nn);
            RETURN ;
          END;

      | 1 => 
          IF NOT SeqM3AST_AS_STM.Exhausted(narrow_iter.iter1) THEN
            SeqM3AST_AS_STM.Update(n.as_stm_s, narrow_iter.iter1, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Case_update;


PROCEDURE Else_stm_update(n: M3AST_AS_F.Else_stm; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Else_stm_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_STM.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_STM.Update(n.as_stm_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Else_stm_update;


PROCEDURE Elsif_update(n: M3AST_AS_F.Elsif; iter: AST_Iter.T; nn: AST.NODE)
    RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Elsif_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          n.as_exp := nn;
          RETURN ;

      | 1 => 
          IF NOT SeqM3AST_AS_STM.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_STM.Update(n.as_stm_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Elsif_update;


PROCEDURE Try_except_update(n: M3AST_AS_F.Try_except; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Try_except_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_Handler.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_Handler.Update(n.as_handler_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      | 1 => 
          n.as_else := nn;
          RETURN ;

      | 2 => 
          IF NOT SeqM3AST_AS_STM.Exhausted(narrow_iter.iter1) THEN
            SeqM3AST_AS_STM.Update(n.as_stm_s, narrow_iter.iter1, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Try_except_update;


PROCEDURE Try_finally_update(n: M3AST_AS_F.Try_finally; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Try_finally_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_STM.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_STM.Update(n.as_stm_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Try_finally_update;


PROCEDURE Tcase_update(n: M3AST_AS_F.Tcase; iter: AST_Iter.T; nn: AST.NODE)
    RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Tcase_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_M3TYPE.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_M3TYPE.Update(n.as_type_s, narrow_iter.iter0, nn);
            RETURN ;
          END;

      | 1 => 
          n.as_id := nn;
          RETURN ;

      | 2 => 
          IF NOT SeqM3AST_AS_STM.Exhausted(narrow_iter.iter1) THEN
            SeqM3AST_AS_STM.Update(n.as_stm_s, narrow_iter.iter1, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Tcase_update;


PROCEDURE Handler_update(n: M3AST_AS_F.Handler; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  VAR
    narrow_iter:= NARROW(iter, Handler_iter);
  BEGIN
    LOOP
      CASE iter.slot OF
      | 0 => 
          IF NOT SeqM3AST_AS_Qual_used_id.Exhausted(narrow_iter.iter0) THEN
            SeqM3AST_AS_Qual_used_id.Update(n.as_qual_id_s, narrow_iter.iter0, 
                nn);
            RETURN ;
          END;

      | 1 => 
          n.as_id := nn;
          RETURN ;

      | 2 => 
          IF NOT SeqM3AST_AS_STM.Exhausted(narrow_iter.iter1) THEN
            SeqM3AST_AS_STM.Update(n.as_stm_s, narrow_iter.iter1, nn);
            RETURN ;
          END;

      END;
      INC(iter.slot);
    END;
  END Handler_update;


PROCEDURE Binding_update(n: M3AST_AS_F.Binding; iter: AST_Iter.T; 
    nn: AST.NODE) RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_id := nn;

    | 1 => 
        n.as_exp := nn;

    END;
  END Binding_update;


PROCEDURE By_update(n: M3AST_AS_F.By; iter: AST_Iter.T; nn: AST.NODE)
    RAISES {}=
  BEGIN
    CASE iter.slot OF
    | 0 => 
        n.as_exp := nn;

    END;
  END By_update;

BEGIN
END M3AST_AS_Iter.