namespace std {
  struct istream;
  template<typename T, typename = void> struct vector { using iterator = T*; };

  template<bool, typename = void> struct enable_if { };
  template<typename T> struct enable_if<true, T> { using type = T; };

  template<typename T> T&& declval();

  template<typename From, typename To>
    struct is_convertible
    {
      using true_type = char;
      struct false_type { char d[2]; };

      template<typename _To1>
	static void __test_aux(_To1) noexcept;

      template<typename _From1, typename _To1,
	       typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
	static true_type
	__test(int);

      template<typename, typename>
	static false_type
	__test(...);

      static constexpr bool value = sizeof(__test<From, To>(0)) == 1;
    };
}

namespace a {
template < int > struct b { typedef int type; };
template < typename > struct c;
template < typename d > struct e {
  enum { f };
  typename b< sizeof(d) >::type NonInteger;
};
template < typename, int = 0, typename = int > class g;
template < typename h, typename = typename g< h >::i > class aa {};
template < typename j > class k {
public:
  typedef j i;
  typename b< e< typename c< j >::h >::f >::type l;
};
template < typename n, int ab, typename o > struct c< g< n, ab, o > > {
  typedef n h;
};
template < typename n, int , typename > class g : public k< g< n > > {};
} namespace p {}
namespace boost {
namespace ac {
using namespace p;
}
} namespace p {
template < bool s > struct q { static const bool value = s; };
struct ad {
  typedef int ae;
};
} namespace boost {
namespace ac {
template < typename d > struct af { typedef d type; };
template < int, typename ag, typename > struct u { typedef ag type; };
template < typename ag, typename ah > struct u< false, ag, ah > {
  typedef ah type;
};
template < typename ag, typename ah, typename ai > struct w {
  typedef typename u< ag::value, ah, ai >::type type;
};
template < typename y, typename z, typename aj > struct ak {
  typedef typename w< y, z, aj >::type ::type type;
};
} template < int al > struct am { static const int value = al; };
namespace ac {
struct always {
  struct an {
    typedef q< false > type;
  };
};
} } class ao {
  class aq {
    aq as(std::istream &);
    using at = a::g< int >;
    at aw;
  };
};
namespace boost {
namespace serialization {
template < class d > struct bd { d value(); };
template < class d > bd< d > be(char *, d);
struct bf {
  bf(int);
  operator int();
};
template < class au, class d > void bg(au ar, d t) {
  bf v(0);
  av(ar, t, v);
}
template < class au, class d > struct bh {
  static void bi(au ar) {
    d t;
    bf v(0);
    bj(ar, t, v);
  }
};
template < class au, class d > void bk(au, d, int) {
  typedef
      typename ac::ak< typename au::bl, int, ac::af< bh< au, d > > >::type bm;
  bm::bi;
}
class bo {
public:
  bo(int);
};
} namespace ac {
template < typename > struct greater_equal_impl;
template < typename bp >
struct bq : greater_equal_impl< typename bp::ae >::template an< int, bp > {};
template <> struct greater_equal_impl< int > {
  template < typename, typename > struct an : q< 1 > {};
};
} namespace serialization {
namespace br {
template < class au, class d > int bs(au ar, d, int, bo) {
  typename d::iterator bt;
  ar >> be("", *bt);
}
} struct bu : ac::always {};
template < class au, class U, class bv >
void bj(au ar, std::vector< U, bv > t, int, ac::q< false >) {
  bo bw(0);
  int bx;
  br::bs(ar, t, bx, bw);
}
template < class au, class U, class bv >
void bj(au ar, std::vector< U, bv > t, int bb) {
  typedef bu::an::type by;
  bj(ar, t, bb, by());
}
template < class au, class U, class bv >
void av(au art, int bb) {
  }
} } namespace boost::serialization {
template < typename au, typename h, typename bz >
void bj(au, a::aa< h, bz >, bf);
template < typename au, typename h, typename bz >
void av(au ar, a::aa< h, bz > t, bf ca) {
  bk(ar, t, ca);
}
template < typename au, typename cb >
typename std::enable_if<
    std::is_convertible< cb *, a::k< cb > * >::value >::type
bj(au ar, cb, bf) {
  std::vector< a::aa< typename cb::i > > cc;
  ar >> be("", cc);
}
template < typename au, typename cb >
typename std::enable_if<
    std::is_convertible< cb *, a::k< cb > * >::value >av(au ar, cb m, bf ca) {
  bk(ar, m, ca);
}
} namespace boost {
namespace serialization {
template < class > class cd {};
template < class d, class U > d ce(U);
} template < class, class > class cg {
  void ch(int &) const __attribute__((__used__));
};
void *ci;
template < class au, class d > void cg< au, d >::ch(int &ar) const {
  serialization::bg(serialization::ce< au >(ar), *static_cast< d * >(ci));
}
template < class au > struct cj {
  struct ck {
    template < class d > static void bi(au, d ) {
      void *x;
      x, serialization::cd< cg< au, d > >();
    }
  };
  template < class d > static void bi(au ar, d t) {
    typedef typename ac::ak< ac::bq< ac::ad >, ac::af< ck >, int >::type bm;
    bm::bi(ar, t);
  }
};
template < class au, class d > void bj(au ar, d t) {
  typedef
      typename ac::ak< am< __is_enum(int) >, int, ac::af< cj< au > > >::type bm;
  bm::bi(ar, t);
}
class cl;
template < class > class interface_iarchive {
public:
  typedef ac::q< false > bl;
  cl *cm();
  template < class d > cl &operator>>(d t) { cm()->cn(t); }
};
class co : public interface_iarchive< int > {
protected:
  template < class d > void cn(d t) {
    cl *__trans_tmp_1 ;
    bj(*__trans_tmp_1, t);
  }
};
class cp : public co {
  friend interface_iarchive;
  template < class d > void cn(serialization::bd< d > t) {
    d __trans_tmp_2 ;
    co::cn(__trans_tmp_2);
  }
};
template < class > class cq : public cp {
protected:
  cq(std::istream &, int);
};
class cl : public cq< cl > {
public:
  cl(std::istream &cr, int cs = 0) : cq(cr, cs) {}
};
namespace serialization {
template < class au, template < class > class ct > void bj(au, ct< class U >);
}
} using cu = boost::cl;
ao::aq ao::aq::as(std::istream &cr) {
  cu ar(cr);
  ar >> boost::serialization::be("", aw);
}