namespace a {
       template <typename aa, aa c> struct d {
      static constexpr aa e = c;
      };
       template <typename f, typename g> struct h {
        template <typename, typename> static d<bool, false> i();
        typedef decltype(i<f, g>()) j;
      };
       template <typename, typename> struct k : h<int, int>::j {};
       template <int> struct ab {
      typedef int j;
      };
       template <class l, class m> struct ac {
        int ad;
        m n;
        template <class o, class = typename ab<k<o, m>::e>::j>   constexpr ac(l, o &&p) : ad(), n(p) {}
      };
       template <typename> struct af;
       template <typename aa> struct af<const aa *> {
      typedef aa ae;
      };
       }
        using a::af;
        template <typename q> class r {
       public:   typedef typename af<q>::ae ae;
       };
        namespace a {
       enum {
      s };
       template <typename, typename> class t {};
       struct ag {
        static const unsigned short ah = s;
      };
       enum ai {};
       template <typename, typename> class aj;
       namespace ak {
      enum class z {
     al };
      template <typename, typename, typename b, typename am, z, bool> void an(int &, const aj<b, am> &);
      template <typename, typename, typename, bool> class ao;
      }
       template <typename> struct ap {
        struct aq {
         typedef unsigned short ar;
         ar as;
         char at;
         constexpr aq(ar au) : as(au), at() {}
       }
      typedef av;
        template <typename aw> av ax(aw, bool) const;
        bool ay(char, av);
      };
       template <typename az, typename = az> class aj {
        template <bool> friend class ak::ao;
        ap<char> ba;
      };
       template <typename bb, typename y, typename az, typename u> void bc(bb, bb, y, aj<az, u>) {
        ak::an<bb, y, az, u, ak::z::al, true>;
      }
       template <typename bb, typename az, typename u> void bc(bb bd, bb be, aj<az, u> bf) {
        bb bg;
        bc(bd, be, bg, bf);
      }
       template <typename bh, typename bi, typename az, typename u> void bc(t<bh, bi>, aj<az, u> be) {
        r<const char *> v, x;
        bc(v, x, be);
      }
       namespace ak {
      ai bj;
      template <typename bk, typename, typename b, typename am, z, bool> void an(int &bd, const aj<b, am> &be) {
       bk bl, bm;
       ao<bk, int, am, false> bn(bm, bl, bd, be, bj);
       bn.bo();
     }
      }
       template <typename az> template <typename aw> typename ap<az>::av ap<az>::ax(aw, bool) const {
        ac<char *, av> bp[]{
    {
   "", ag::ah}
    };
      }
       namespace ak {
      template <typename bk, typename, typename, bool> class ao {
       typedef typename bk::ae b;
       typedef aj<b> bq;
     public:   ao(bk, bk, int, bq, ai);
       void bo() {
    br<true>();
    }
       template <bool> bool br();
       b bs;
       bq bt;
     };
      template <typename bk, typename y, typename am, bool bu> template <bool> bool ao<bk, y, am, bu>::br() {
       b bm = bt.ba.ay(bs, bt.ba.ax(bm, 1));
     }
      }
       }
        class I {
         void operator()(int, int) const;
         a::aj<char> w;
       };
        void I::operator()(int, int) const {
         a::t<char, int> bv;
         bc(bv, w);
       }
