namespace std
{
template <typename _Tp, _Tp __v> struct integral_constant
{
  static constexpr _Tp value = __v;
  typedef integral_constant type;
};
typedef integral_constant<int, 1> true_type;
typedef integral_constant<int, 0> false_type;
template <bool, typename, typename> struct conditional;
template <typename...> struct __or_;
template <typename _B1, typename _B2>
struct __or_<_B1, _B2> : conditional<_B1::value, _B1, _B2>::type
{
};
template <typename...> struct __and_;
template <typename _B1, typename _B2>
struct __and_<_B1, _B2> : conditional<_B1::value, _B2, _B1>::type
{
};
template <typename _Pp> struct __not_ : integral_constant<int, !_Pp::value>
{
};
struct __is_void_helper : false_type
{
};
struct is_void : __is_void_helper::type
{
};
struct is_lvalue_reference : false_type
{
};
template <typename> struct is_rvalue_reference : false_type
{
};
template <typename _Tp> struct is_rvalue_reference<_Tp &&> : true_type
{
};
template <typename> struct is_function : false_type
{
};
template <typename _Tp>
struct is_reference
    : __or_<is_lvalue_reference, is_rvalue_reference<_Tp> >::type
{
};
template <typename _Tp> _Tp declval ();
template <typename> struct remove_all_extents;
struct __do_is_destructible_impl
{
  template <typename _Tp, typename = decltype(declval<_Tp &>().~_Tp)>
  static true_type __test (int);
};
template <typename _Tp>
struct __is_destructible_impl : __do_is_destructible_impl
{
  typedef decltype(__test<_Tp>(0)) type;
};
template <typename _Tp>
struct __is_destructible_safe
    : __is_destructible_impl<typename remove_all_extents<_Tp>::type>::type
{
};
template <typename _Tp>
struct is_destructible : __is_destructible_safe<_Tp>::type
{
};
struct __do_is_static_castable_impl
{
  template <typename _From, typename _To,
            typename = decltype(static_cast<_To>(declval<_From>()))>
  static true_type __test (int);
};
template <typename _From, typename _To>
struct __is_static_castable_impl : __do_is_static_castable_impl
{
  typedef decltype(__test<_From, _To>(0)) type;
};
template <typename _From, typename _To>
struct __is_static_castable_safe : __is_static_castable_impl<_From, _To>::type
{
};
template <typename _From, typename _To>
struct __is_static_castable
    : integral_constant<bool, __is_static_castable_safe<_From, _To>::value>
{
};
struct __do_is_direct_constructible_impl
{
  template <typename, typename> static false_type __test (...);
};
template <typename _Tp, typename _Arg>
struct __is_direct_constructible_impl : __do_is_direct_constructible_impl
{
  typedef decltype(__test<_Tp, _Arg>()) type;
};
template <typename _Arg>
struct __is_direct_constructible_new_safe
    : __and_<is_destructible<int>, __is_direct_constructible_impl<int, _Arg> >
{
};
template <typename> struct is_same;
template <typename _From, typename,
          int = __not_<__or_<is_void, is_function<_From> > >::value>
struct __is_base_to_derived_ref;
template <typename, typename... _Args> struct is_constructible;
template <typename _From, typename _To>
struct __is_base_to_derived_ref<_From, _To, true>
{
  typedef _To __dst_t;
  typedef __and_<__not_<is_same<__dst_t> >,
                 __not_<is_constructible<__dst_t, _From> > > type;
  static constexpr int value = type::value;
};
template <typename _Tp, typename _Arg>
struct __is_direct_constructible_ref_cast
    : __and_<__is_static_castable<_Arg, _Tp>,
             __not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>, false_type> > >
{
};
template <typename _Tp, typename _Arg>
struct __is_direct_constructible_new
    : conditional<is_reference<_Tp>::value,
                  __is_direct_constructible_ref_cast<_Tp, _Arg>,
                  __is_direct_constructible_new_safe<_Arg> >::type
{
};
template <typename _Tp, typename _Arg>
struct __is_direct_constructible
    : __is_direct_constructible_new<_Tp, _Arg>::type
{
};
template <typename, typename... _Args> struct __is_nary_constructible;
template <typename _Tp, typename _Arg>
struct __is_nary_constructible<_Tp, _Arg>
    : __is_direct_constructible<_Tp, _Arg>
{
};
template <typename _Tp, typename... _Args>
struct is_constructible : __is_nary_constructible<_Tp, _Args...>::type
{
};
template <typename _Tp> struct is_copy_constructible;
template <typename _Tp>
struct __is_move_constructible_impl : is_constructible<_Tp, _Tp &&>
{
};
template <typename _Tp>
struct is_move_constructible : __is_move_constructible_impl<_Tp>
{
};
template <typename, typename... _Args> struct __is_nt_constructible_impl;
template <typename, typename... _Args>
struct is_nothrow_constructible
    : __and_<is_constructible<int, _Args...>,
             __is_nt_constructible_impl<int, _Args...> >
{
};
template <typename _Tp>
struct __is_nothrow_move_constructible_impl
    : is_nothrow_constructible<_Tp, _Tp &&>
{
};
template <typename _Tp>
struct is_nothrow_move_constructible
    : __is_nothrow_move_constructible_impl<_Tp>
{
};
template <typename _Tp> struct is_same : true_type
{
};
template <typename _Tp> struct remove_all_extents
{
  typedef int type;
};
template <bool> struct enable_if
{
  typedef int type;
};
template <bool, typename _Iftrue, typename _Iffalse> struct conditional
{
  typedef _Iftrue type;
};
template <typename _Iftrue, typename _Iffalse>
struct conditional<false, _Iftrue, _Iffalse>
{
  typedef _Iffalse type;
};
template <typename _Tp> using decay_t = int;
template <bool, typename = void> using enable_if_t = int;
template <bool _Cond, typename _Iftrue, typename _Iffalse>
using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type;
template <typename _Tp> struct __is_in_place_type;
class any
{
  template <typename _Tp, typename _Safe = is_nothrow_move_constructible<_Tp>,
            int _Fits = alignof 0>
  using _Internal = std::integral_constant<bool, _Safe::value && _Fits>;
  template <typename _Tp> struct _Manager_internal;
  template <typename _Tp> struct _Manager_external;
  template <typename _Tp>
  using _Manager = conditional_t<_Internal<_Tp>::value, _Manager_internal<_Tp>,
                                 _Manager_external<_Tp> >;
  template <typename _Tp, typename _Decayed = decay_t<_Tp> >
  using _Decay = enable_if_t<is_same<int>::value, _Decayed>;

public:
  any ();
  template <typename _ValueType, typename _Tp = _Decay<_ValueType>,
            typename _Mgr = _Manager<_Tp>,
            enable_if_t<__and_<is_copy_constructible<_Tp>,
                               __not_<is_constructible<_Tp, _ValueType &&> >,
                               __not_<__is_in_place_type<_ValueType> > >::
                            value,
                        bool> = false>
  any (_ValueType &&)
      : _M_manager (&_Mgr::_S_manage)
  {
  }
private:
  enum _Op
  {
  };
  void (*_M_manager)(_Op, const any *, int *);
  template <typename _Tp> struct _Manager_external
  {
    static void _S_manage (_Op, const any *, int *);
  };
};
template <typename _ValueType,
          typename enable_if<is_move_constructible<_ValueType>::value
                             && is_lvalue_reference::value>::type = false>
_ValueType any_cast (any &&)
{
}
}

using std::any_cast;
void test03 ()
{
  struct MoveDeleted;
  MoveDeleted &&md3 = any_cast<MoveDeleted &&>(0);
}