text: /* Code in this file is generated.  -*- buffer-read-only: t -*- vi:set ro:
     See the procedure `make_source' in nested-types.exp.  */
  
  /* This testcase is part of GDB, the GNU debugger.
  
     Copyright 2017-2020 Free Software Foundation, Inc.
  
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 3 of the License, or
     (at your option) any later version.
  
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
  
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  
  struct S10 {
    enum E10 {A10, B10, C10};
    union U10 {
      int a;
      char c;
    };
  
    int i10;
    E10 e10;
    U10 u10;
  
    struct S11 {
      enum E11 {A11, B11, C11};
      union U11 {
        int a;
        char c;
      };
  
      int i11;
      E11 e11;
      U11 u11;
  
      struct S12 {
        enum E12 {A12, B12, C12};
        union U12 {
          int a;
          char c;
        };
  
        int i12;
        E12 e12;
        U12 u12;
  
        struct S13 {
          enum E13 {A13, B13, C13};
          union U13 {
            int a;
            char c;
          };
  
          int i13;
          E13 e13;
          U13 u13;
  
          struct S14 {
            enum E14 {A14, B14, C14};
            union U14 {
              int a;
              char c;
            };
  
            int i14;
            E14 e14;
            U14 u14;
  
            struct S15 {
              enum E15 {A15, B15, C15};
              union U15 {
                int a;
                char c;
              };
  
              int i15;
              E15 e15;
              U15 u15;
  
              struct S16 {
                enum E16 {A16, B16, C16};
                union U16 {
                  int a;
                  char c;
                };
  
                int i16;
                E16 e16;
                U16 u16;
  
                struct S17 {
                  enum E17 {A17, B17, C17};
                  union U17 {
                    int a;
                    char c;
                  };
  
                  int i17;
                  E17 e17;
                  U17 u17;
  
                  struct S18 {
                    enum E18 {A18, B18, C18};
                    union U18 {
                      int a;
                      char c;
                    };
  
                    int i18;
                    E18 e18;
                    U18 u18;
  
                    struct S19 {
                      enum E19 {A19, B19, C19};
                      union U19 {
                        int a;
                        char c;
                      };
  
                      int i19;
                      E19 e19;
                      U19 u19;
  
                    };
                  };
                };
              };
            };
          };
        };
      };
    };
    struct S21 {
      enum E21 {A21, B21, C21};
      union U21 {
        int a;
        char c;
      };
  
      int i21;
      E21 e21;
      U21 u21;
  
      struct S22 {
        enum E22 {A22, B22, C22};
        union U22 {
          int a;
          char c;
        };
  
        int i22;
        E22 e22;
        U22 u22;
  
        struct S23 {
          enum E23 {A23, B23, C23};
          union U23 {
            int a;
            char c;
          };
  
          int i23;
          E23 e23;
          U23 u23;
  
          struct S24 {
            enum E24 {A24, B24, C24};
            union U24 {
              int a;
              char c;
            };
  
            int i24;
            E24 e24;
            U24 u24;
  
            struct S25 {
              enum E25 {A25, B25, C25};
              union U25 {
                int a;
                char c;
              };
  
              int i25;
              E25 e25;
              U25 u25;
  
              struct S26 {
                enum E26 {A26, B26, C26};
                union U26 {
                  int a;
                  char c;
                };
  
                int i26;
                E26 e26;
                U26 u26;
  
                struct S27 {
                  enum E27 {A27, B27, C27};
                  union U27 {
                    int a;
                    char c;
                  };
  
                  int i27;
                  E27 e27;
                  U27 u27;
  
                  struct S28 {
                    enum E28 {A28, B28, C28};
                    union U28 {
                      int a;
                      char c;
                    };
  
                    int i28;
                    E28 e28;
                    U28 u28;
  
                    struct S29 {
                      enum E29 {A29, B29, C29};
                      union U29 {
                        int a;
                        char c;
                      };
  
                      int i29;
                      E29 e29;
                      U29 u29;
  
                    };
                  };
                };
              };
            };
          };
        };
      };
    };
    struct S31 {
      enum E31 {A31, B31, C31};
      union U31 {
        int a;
        char c;
      };
  
      int i31;
      E31 e31;
      U31 u31;
  
      struct S32 {
        enum E32 {A32, B32, C32};
        union U32 {
          int a;
          char c;
        };
  
        int i32;
        E32 e32;
        U32 u32;
  
        struct S33 {
          enum E33 {A33, B33, C33};
          union U33 {
            int a;
            char c;
          };
  
          int i33;
          E33 e33;
          U33 u33;
  
          struct S34 {
            enum E34 {A34, B34, C34};
            union U34 {
              int a;
              char c;
            };
  
            int i34;
            E34 e34;
            U34 u34;
  
            struct S35 {
              enum E35 {A35, B35, C35};
              union U35 {
                int a;
                char c;
              };
  
              int i35;
              E35 e35;
              U35 u35;
  
              struct S36 {
                enum E36 {A36, B36, C36};
                union U36 {
                  int a;
                  char c;
                };
  
                int i36;
                E36 e36;
                U36 u36;
  
                struct S37 {
                  enum E37 {A37, B37, C37};
                  union U37 {
                    int a;
                    char c;
                  };
  
                  int i37;
                  E37 e37;
                  U37 u37;
  
                  struct S38 {
                    enum E38 {A38, B38, C38};
                    union U38 {
                      int a;
                      char c;
                    };
  
                    int i38;
                    E38 e38;
                    U38 u38;
  
                    struct S39 {
                      enum E39 {A39, B39, C39};
                      union U39 {
                        int a;
                        char c;
                      };
  
                      int i39;
                      E39 e39;
                      U39 u39;
  
                    };
                  };
                };
              };
            };
          };
        };
      };
    };
    struct S41 {
      enum E41 {A41, B41, C41};
      union U41 {
        int a;
        char c;
      };
  
      int i41;
      E41 e41;
      U41 u41;
  
      struct S42 {
        enum E42 {A42, B42, C42};
        union U42 {
          int a;
          char c;
        };
  
        int i42;
        E42 e42;
        U42 u42;
  
        struct S43 {
          enum E43 {A43, B43, C43};
          union U43 {
            int a;
            char c;
          };
  
          int i43;
          E43 e43;
          U43 u43;
  
          struct S44 {
            enum E44 {A44, B44, C44};
            union U44 {
              int a;
              char c;
            };
  
            int i44;
            E44 e44;
            U44 u44;
  
            struct S45 {
              enum E45 {A45, B45, C45};
              union U45 {
                int a;
                char c;
              };
  
              int i45;
              E45 e45;
              U45 u45;
  
              struct S46 {
                enum E46 {A46, B46, C46};
                union U46 {
                  int a;
                  char c;
                };
  
                int i46;
                E46 e46;
                U46 u46;
  
                struct S47 {
                  enum E47 {A47, B47, C47};
                  union U47 {
                    int a;
                    char c;
                  };
  
                  int i47;
                  E47 e47;
                  U47 u47;
  
                  struct S48 {
                    enum E48 {A48, B48, C48};
                    union U48 {
                      int a;
                      char c;
                    };
  
                    int i48;
                    E48 e48;
                    U48 u48;
  
                    struct S49 {
                      enum E49 {A49, B49, C49};
                      union U49 {
                        int a;
                        char c;
                      };
  
                      int i49;
                      E49 e49;
                      U49 u49;
  
                    };
                  };
                };
              };
            };
          };
        };
      };
    };
    struct S51 {
      enum E51 {A51, B51, C51};
      union U51 {
        int a;
        char c;
      };
  
      int i51;
      E51 e51;
      U51 u51;
  
      struct S52 {
        enum E52 {A52, B52, C52};
        union U52 {
          int a;
          char c;
        };
  
        int i52;
        E52 e52;
        U52 u52;
  
        struct S53 {
          enum E53 {A53, B53, C53};
          union U53 {
            int a;
            char c;
          };
  
          int i53;
          E53 e53;
          U53 u53;
  
          struct S54 {
            enum E54 {A54, B54, C54};
            union U54 {
              int a;
              char c;
            };
  
            int i54;
            E54 e54;
            U54 u54;
  
            struct S55 {
              enum E55 {A55, B55, C55};
              union U55 {
                int a;
                char c;
              };
  
              int i55;
              E55 e55;
              U55 u55;
  
              struct S56 {
                enum E56 {A56, B56, C56};
                union U56 {
                  int a;
                  char c;
                };
  
                int i56;
                E56 e56;
                U56 u56;
  
                struct S57 {
                  enum E57 {A57, B57, C57};
                  union U57 {
                    int a;
                    char c;
                  };
  
                  int i57;
                  E57 e57;
                  U57 u57;
  
                  struct S58 {
                    enum E58 {A58, B58, C58};
                    union U58 {
                      int a;
                      char c;
                    };
  
                    int i58;
                    E58 e58;
                    U58 u58;
  
                    struct S59 {
                      enum E59 {A59, B59, C59};
                      union U59 {
                        int a;
                        char c;
                      };
  
                      int i59;
                      E59 e59;
                      U59 u59;
  
                    };
                  };
                };
              };
            };
          };
        };
      };
    };
  };
  
  int
  main ()
  {
    S10 s10;
    S10::S11 s11;
    S10::S11::S12 s12;
    S10::S11::S12::S13 s13;
    S10::S11::S12::S13::S14 s14;
    S10::S11::S12::S13::S14::S15 s15;
    S10::S11::S12::S13::S14::S15::S16 s16;
    S10::S11::S12::S13::S14::S15::S16::S17 s17;
    S10::S11::S12::S13::S14::S15::S16::S17::S18 s18;
    S10::S11::S12::S13::S14::S15::S16::S17::S18::S19 s19;
  
    S10::S21 s21;
    S10::S21::S22 s22;
    S10::S21::S22::S23 s23;
    S10::S21::S22::S23::S24 s24;
    S10::S21::S22::S23::S24::S25 s25;
    S10::S21::S22::S23::S24::S25::S26 s26;
    S10::S21::S22::S23::S24::S25::S26::S27 s27;
    S10::S21::S22::S23::S24::S25::S26::S27::S28 s28;
    S10::S21::S22::S23::S24::S25::S26::S27::S28::S29 s29;
  
    S10::S31 s31;
    S10::S31::S32 s32;
    S10::S31::S32::S33 s33;
    S10::S31::S32::S33::S34 s34;
    S10::S31::S32::S33::S34::S35 s35;
    S10::S31::S32::S33::S34::S35::S36 s36;
    S10::S31::S32::S33::S34::S35::S36::S37 s37;
    S10::S31::S32::S33::S34::S35::S36::S37::S38 s38;
    S10::S31::S32::S33::S34::S35::S36::S37::S38::S39 s39;
  
    S10::S41 s41;
    S10::S41::S42 s42;
    S10::S41::S42::S43 s43;
    S10::S41::S42::S43::S44 s44;
    S10::S41::S42::S43::S44::S45 s45;
    S10::S41::S42::S43::S44::S45::S46 s46;
    S10::S41::S42::S43::S44::S45::S46::S47 s47;
    S10::S41::S42::S43::S44::S45::S46::S47::S48 s48;
    S10::S41::S42::S43::S44::S45::S46::S47::S48::S49 s49;
  
    S10::S51 s51;
    S10::S51::S52 s52;
    S10::S51::S52::S53 s53;
    S10::S51::S52::S53::S54 s54;
    S10::S51::S52::S53::S54::S55 s55;
    S10::S51::S52::S53::S54::S55::S56 s56;
    S10::S51::S52::S53::S54::S55::S56::S57 s57;
    S10::S51::S52::S53::S54::S55::S56::S57::S58 s58;
    S10::S51::S52::S53::S54::S55::S56::S57::S58::S59 s59;
    return 0;
  }
  