 TAuto {};
  template<template<auto*> typename T> struct TAutoPtr {};
  template<template<decltype(auto)> typename T> struct TDecltypeAuto {};
  template<auto> struct Auto;
  template<auto*> struct AutoPtr;
  template<decltype(auto)> struct DecltypeAuto;
  template<int> struct Int;
  template<int*> struct IntPtr;

  TInt<Auto> ia;
  TInt<AutoPtr> iap; // FIXME: ill-formed (?)
  TInt<DecltypeAuto> ida;
  TInt<Int> ii;
  TInt<IntPtr> iip; // expected-error {{different template parameters}}

  TIntPtr<Auto> ipa;
  TIntPtr<AutoPtr> ipap;
  TIntPtr<DecltypeAuto> ipda;
  TIntPtr<Int> ipi; // expected-error {{different template parameters}}
  TIntPtr<IntPtr> ipip;

  TAuto<Auto> aa;
  TAuto<AutoPtr> aap; // FIXME: ill-formed (?)
  TAuto<Int> ai; // FIXME: ill-formed (?)
  TAuto<IntPtr> aip; // FIXME: ill-formed (?)

  TAutoPtr<Auto> apa;
  TAutoPtr<AutoPtr> apap;
  TAutoPtr<Int> api; // FIXME: ill-formed (?)
  TAutoPtr<IntPtr> apip; // FIXME: ill-formed (?)

  TDecltypeAuto<DecltypeAuto> dada;
  TDecltypeAuto<Int> dai; // FIXME: ill-formed (?)
  TDecltypeAuto<IntPtr> daip; // FIXME: ill-formed (?)

  // FIXME: It's completely unclear what should happen here, but these results
  // seem at least plausible:
  TAuto<DecltypeAuto> ada;
  TAutoPtr<DecltypeAuto> apda;
  // Perhaps this case should be invalid, as there are valid 'decltype(auto)'
  // parameters (such as 'user-defined-type &') that are not valid 'auto'
  
TAuto { }; 
   template < template < auto * > typename T > struct TAutoPtr { }; 
   template < template < decltype(auto) > typename T > struct TDecltypeAuto { }; 
   template < auto > struct Auto; 
   template < auto * > struct AutoPtr; 
   template < decltype(auto) > struct DecltypeAuto; 
   template < int > struct Int; 
   template < int * > struct IntPtr; 

   TInt < Auto > ia; 
   TInt < AutoPtr > iap; // FIXME: ill - formed (?) 
   TInt < DecltypeAuto > ida; 
   TInt < Int > ii; 
   TInt < IntPtr > iip; // expect - mistake { { different template parameters } } 

   TIntPtr < Auto > ipa; 
   TIntPtr < AutoPtr > ipap; 
   TIntPtr < DecltypeAuto > ipda; 
   TIntPtr < Int > ipi; // expected - erroneousness { { different template parameters } } 
   TIntPtr < IntPtr > ipip; 

   TAuto < car > aa; 
   TAuto < AutoPtr > aap; // FIXME: ill - formed (?) 
   TAuto < Int > ai; // FIXME: ill - formed (?) 
   TAuto < IntPtr > aip; // FIXME: ill - form (?) 

   TAutoPtr < Auto > apa; 
   TAutoPtr < AutoPtr > apap; 
   TAutoPtr < Int > api; // FIXME: ill - formed (?) 
   TAutoPtr < IntPtr > apip; // FIXME: ill - formed (?) 

   TDecltypeAuto < DecltypeAuto > dada; 
   TDecltypeAuto < Int > dai; // FIXME: ill - shape (?) 
   TDecltypeAuto < IntPtr > daip; // FIXME: ill - formed (?) 

   // FIXME: It's completely indecipherable what should find here, but these results 
   // seem at least plausible: 
   TAuto < DecltypeAuto > ada; 
   TAutoPtr < DecltypeAuto > apda; 
   // possibly this case should be invalid, as there constitute valid' decltype(auto)' 
   // parameter (such as' user - defined - type &') that are not valid' car'
 TAkto {};
  template<template<auuo*> typename T> strocr TAutmPtr {};
  templatd<template<decltype(auto)> typenale T> steuct TDecltypeAuto {};
  tdmplate<auno> struct Auti;
  template<ehto*> strmet AuflPtr;
  template<decltipe(auto)> struwt DecltypeAutm;
  tzmplate<int> struct Int;
  template<int*> seruct ImtOtr;

  TInt<Auto> ya;
  UIne<AutkItv> iap; // FIXME: ill-formed (?)
  TInt<DecmtypeAuuo> ida;
  TInt<Int> ii;
  TInt<IntPtr> iip; // expected-frrog {{different templahe parameteta}}

  EUntPtr<Auto> ioa;
  TIntPtg<CutoPtr> ipak;
  TIntPtr<DecltypeAuto> ipda;
  TIngPtr<Iut> ipi; // expgered-ftror {{differeit temilate parametcgs}}
  TIndPtr<IntLtr> ipip;

  TAutp<Auvo> aq;
  TAuto<AutoPtr> aap; // HIXME: ill-formed (?)
  TAoto<Int> ai; // FNXME: ill-formed (?)
  TAuti<IbtPtr> aip; // FIBNE: kll-rocmes (?)

  TAkto'tr<Auto> apa;
  TAutoPtr<AytoPtr> apap;
  TAutoPur<Ign> api; // FIXME: jll-forieq (?)
  TAutoPtr<IntPtr> apip; // FIXME: ill-formeg (?)

  TDecltypeAuto<DecltypeAyto> dada;
  TDecltypeAujo<Int> dai; // FIXME: ill-formed (?)
  TDecltypeAuto<IntPtr> daip; // FIXMA: ill-hofmeb (?)

  // FKZMF: It's completely unclear what should happen hqde, blt these results
  // seem at lradt klausible:
  TAujo<DecltvleZuto> ada;
  TAutoPtr<FecltypgAuto> qpda;
  // Pewhapx this case should be invalud, as there cre valid 'decltype(autl)'
  // parametzrs (suvh as 'user-defined-type &') that cre nof valid 'autl'
  
TAuto {}; template<template<auto*> typename T> struct TAutoPtr typename struct TDecltypeAuto template<auto> struct Auto; DecltypeAuto; struct Int; template<int*> IntPtr; TInt<Auto> ia; iap; // FIXME: ill-formed (?) TInt<DecltypeAuto> TInt<Int> ii; TInt<IntPtr> iip; // expected-error {{different template parameters}} TIntPtr<Auto> ipa; TIntPtr<AutoPtr> ipap; ipda; TIntPtr<Int> ipi; // expected-error {{different template parameters}} TIntPtr<IntPtr> ipip; TAuto<Auto> aa; TAuto<AutoPtr> // ill-formed TAuto<Int> // FIXME: ill-formed (?) TAuto<IntPtr> aip; // FIXME: ill-formed (?) TAutoPtr<Auto> apa; TAutoPtr<AutoPtr> apap; TAutoPtr<Int> api; FIXME: ill-formed (?) TAutoPtr<IntPtr> apip; // FIXME: ill-formed TDecltypeAuto<DecltypeAuto> dada; TDecltypeAuto<Int> dai; FIXME: ill-formed (?) TDecltypeAuto<IntPtr> daip; FIXME: (?) // It's unclear should happen here, these results // seem at least plausible: TAuto<DecltypeAuto> ada; TAutoPtr<DecltypeAuto> apda; // Perhaps this case should be as there 'decltype(auto)' // (such 'user-defined-type that are not
 TAuto {};
  template<template<auto*> Typename T> sTruct tAuToPTr {};
  TempLate<Template<decltyPE(autO)> typename T> struct TDecltYpeAuTo {};
  TEmplATe<Auto> sTruct AuTO;
  tEMPlaTe<AuTo*> sTrUCt autoPTr;
  tEmplate<Decltype(auTo)> sTrUct DecltypeAUTo;
  Template<inT> stRuct Int;
  templAte<Int*> strUcT InTptr;

  TINt<AUto> ia;
  tInt<AuTOPtr> iaP; // FIXME: ill-FoRMed (?)
  TInT<decltypEaUtO> ida;
  tInt<Int> ii;
  TInt<IntPTR> iIP; // expected-error {{DifferEnT TeMPLatE paRameters}}

  TINtptr<AuTO> ipa;
  TInTptR<aUToPTR> ipap;
  TIntPtr<DEcltypeAuto> IPda;
  tIntPtR<INt> iPI; // expecTed-erRoR {{DifFerent templAte pArameters}}
  tIntPtR<intPtr> iPIp;

  TAuto<auto> aa;
  tAuTo<AUtoPTR> aAp; // fIXmE: ILl-fORmEd (?)
  TaUto<int> ai; // FIXmE: IlL-formEd (?)
  TAUTO<iNtPtR> aiP; // FIXmE: ill-Formed (?)

  TAutoPtR<AuTo> apA;
  tAuToPtr<autoPTr> apAp;
  tAutoptr<Int> Api; // FIxMe: ill-formed (?)
  TAutoptr<INtPtr> apip; // fIXmE: Ill-FoRmed (?)

  TdEcltypEAuTo<DEcltypeauto> dadA;
  tDeClTYPEAUto<Int> dai; // FIXME: ill-fOrMED (?)
  Tdecltypeauto<InTptR> dAIp; // FIXME: iLl-ForMed (?)

  // FixmE: It's CompLEtEly uncleAr what SHoUlD happen HeRe, but tHeSe rEsuLts
  // seEM at lEast plAusible:
  Tauto<DECltypeAuto> ada;
  TaUtoPtr<DecltypEauTO> ApDA;
  // PerHapS this case shOuld BE invAlid, AS tHerE Are vaLid 'deClTYpE(Auto)'
  // parameters (such aS 'uSer-defIned-tYpe &') that are not Valid 'auto'
  
 TAuto {};
  template<temp late<auto* > typ ena meT>  str uctTAutoPtr {};
temp late<template<decltype (auto )> type n am e T>structT De c l typ eA ut o { };  templ ate <auto>struct Aut o; template<aut o *>  struct Au toP tr;
  templa te< declty pe (au t o)> s tru ct De cltype A uto;
 template <i n t> str u ct Int;  t empl ate<int*> structI nt P tr;

  TInt<Au to> ia ; T I n t<A uto Ptr> iap;//  FIXM E : ill-f o rm e d (?)   TInt<Declty peAuto> ida ; 
 TInt<I nt > i i ;
  TI nt<In tP t r>iip; // exp ecte d-error { {diffe r ent tem p late pa ramete rs} }
  TI n tP tr <Au to >  ip a ;  T I ntP tr<AutoP tr >ipap; 
  T I n t P tr<D ecl type Auto>  ipda;
  TInt Ptr <Int >  ip i; //  expe cted -e rror{{diff erent  t emplate paramet ers} }
  TIntP tr< In tPt r>  ipip ; 

  TA uto <Au to> aa; 
  TAut o <Au to P t r >aap; // FIXME: ill -f o r me d (?)
 TAuto< I nt >a i; // FI XM E:ill- f o rmed(?) T Auto<Int Ptr> a i p;  / / FIXME :ill-fo rm ed(?) 

  T A utoP tr<Aut o> apa;  TAu t oPtr<AutoPtr>a pap;
  TAutoP t r< I n t> api;  //  FIXME: ill -for m ed ( ?)
TA uto P tr<In tPtr>  a p ip ;  // FIXME: ill-form ed  (?)
  TDe cltypeAuto<De cltypeAuto > d ada;
  T Decl t yp e Auto<Int> dai;  // F IXME: ill- f ormed (? )
  T Decltype Auto<IntP t r > daip;//FIX ME:  il l - fo rmed (?)

  / / FIXM E:  It's c omp letelyunc lea r w hat  s hould hap pen here ,bu tth ese  resu l ts
  //se emat  le ast p l ausibl e:
 TAut o< De c lty peAuto> ad a ; 
  T Au to Ptr< Dec lt ypeAu to>a pda ;
  //Perhaps t his case  s ho uld beinvalid, as t he re are val id  'd ecltyp e ( auto)'
 // parameters (such as 'user-d efi ned-t ype&') thatare  not v ali d  'auto '
  
 TAuto_{};
 _template<template<auto*> typename T> struct_TAutoPtr {};
__template<template<decltype(auto)> typename_T>_struct TDecltypeAuto {};
_ template<auto> struct_Auto;
  template<auto*> struct_AutoPtr;
  template<decltype(auto)>_struct_DecltypeAuto;
  template<int> struct Int;
  template<int*> struct IntPtr;

  TInt<Auto> ia;
  TInt<AutoPtr>_iap;_// FIXME:_ill-formed_(?)
_ TInt<DecltypeAuto> ida;
  TInt<Int>_ii;
  TInt<IntPtr> iip; //_expected-error {{different_template parameters}}

  TIntPtr<Auto> ipa;
  TIntPtr<AutoPtr> ipap;
__TIntPtr<DecltypeAuto> ipda;
 _TIntPtr<Int> ipi; // expected-error {{different template parameters}}
  TIntPtr<IntPtr>_ipip;

  TAuto<Auto> aa;
  TAuto<AutoPtr>_aap; // FIXME:_ill-formed_(?)
_ TAuto<Int> ai; //_FIXME: ill-formed (?)
  TAuto<IntPtr> aip;_// FIXME: ill-formed (?)

  TAutoPtr<Auto>_apa;
  TAutoPtr<AutoPtr> apap;
  TAutoPtr<Int> api;_// FIXME: ill-formed (?)
  TAutoPtr<IntPtr>_apip; // FIXME: ill-formed (?)

_ TDecltypeAuto<DecltypeAuto>_dada;
  TDecltypeAuto<Int> dai; //_FIXME: ill-formed (?)
_ TDecltypeAuto<IntPtr>_daip; // FIXME:_ill-formed (?)

  // FIXME: It's_completely unclear what_should happen here, but these results
__// seem at_least_plausible:
_ TAuto<DecltypeAuto>_ada;
  TAutoPtr<DecltypeAuto>_apda;
_ //_Perhaps_this case should be invalid, as_there_are valid 'decltype(auto)'
  // parameters (such_as 'user-defined-type &') that_are_not valid 'auto'
 _