Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
preprocessed source
This file has been truncated, but you can view the full file.
# 1 "<built-in>" 1
# 1 "tree.i" 1
# 1 "tree.cc"
# 1 "<built-in>" 1
# 1 "<built-in>" 3
# 194 "<built-in>" 3
# 1 "<command line>" 1
# 1 "<built-in>" 2
# 1 "tree.cc" 2
# 1 "./rpc.hh" 1
# 1 "./first.hh" 1
# 5 "./rpc.hh" 2
# 1 "./cxx_invoke.hh" 1
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/utility" 1
# 59 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/utility" 3
# 68 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/utility" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/c++config.h" 1 3
# 186 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/c++config.h" 3
namespace std {
typedef long unsigned int size_t;
typedef long int ptrdiff_t;
typedef decltype(nullptr) nullptr_t;
}
# 430 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/c++config.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/os_defines.h" 1 3
# 431 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/c++config.h" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/cpu_defines.h" 1 3
# 434 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/x86_64-apple-darwin13.2.0/bits/c++config.h" 2 3
# 69 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/utility" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_relops.h" 1 3
# 67 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_relops.h" 3
namespace std __attribute__((__visibility__("default"))) {
namespace rel_ops {
# 85 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_relops.h" 3
template <class _Tp> inline bool operator!=(const _Tp &__x, const _Tp &__y) {
return !(__x == __y);
}
# 98 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_relops.h" 3
template <class _Tp> inline bool operator>(const _Tp &__x, const _Tp &__y) {
return __y < __x;
}
# 111 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_relops.h" 3
template <class _Tp> inline bool operator<=(const _Tp &__x, const _Tp &__y) {
return !(__y < __x);
}
# 124 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_relops.h" 3
template <class _Tp> inline bool operator>=(const _Tp &__x, const _Tp &__y) {
return !(__x < __y);
}
}
}
# 70 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/utility" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_pair.h" 1 3
# 59 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_pair.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/move.h" 1 3
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/move.h" 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/concept_check.h" 1 3
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/concept_check.h" 3
# 35 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/move.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
template <typename _Tp> inline _Tp *__addressof(_Tp & __r) noexcept {
return reinterpret_cast<_Tp *>(
&const_cast<char &>(reinterpret_cast<const volatile char &>(__r)));
}
}
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 1 3
# 33 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
namespace std __attribute__((__visibility__("default"))) {
# 56 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <typename _Tp, _Tp __v> struct integral_constant {
static constexpr _Tp value = __v;
typedef _Tp value_type;
typedef integral_constant<_Tp, __v> type;
constexpr operator value_type() const { return value; }
};
template <typename _Tp, _Tp __v>
constexpr _Tp integral_constant<_Tp, __v>::value;
typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;
template <bool, typename, typename> struct conditional;
template <typename...> struct __or_;
template <> struct __or_<> : public false_type {};
template <typename _B1> struct __or_<_B1> : public _B1 {};
template <typename _B1, typename _B2>
struct __or_<_B1, _B2> : public conditional<_B1::value, _B1, _B2>::type {};
template <typename _B1, typename _B2, typename _B3, typename... _Bn>
struct __or_<_B1, _B2, _B3,
_Bn...> : public conditional<_B1::value, _B1,
__or_<_B2, _B3, _Bn...> >::type {};
template <typename...> struct __and_;
template <> struct __and_<> : public true_type {};
template <typename _B1> struct __and_<_B1> : public _B1 {};
template <typename _B1, typename _B2>
struct __and_<_B1, _B2> : public conditional<_B1::value, _B2, _B1>::type {};
template <typename _B1, typename _B2, typename _B3, typename... _Bn>
struct __and_<_B1, _B2, _B3,
_Bn...> : public conditional<_B1::value,
__and_<_B2, _B3, _Bn...>,
_B1>::type {};
template <typename _Pp>
struct __not_ : public integral_constant<bool, !_Pp::value> {};
template <typename _Tp> struct __success_type {
typedef _Tp type;
};
struct __failure_type {};
template <typename> struct remove_cv;
template <typename> struct __is_void_helper : public false_type {};
template <> struct __is_void_helper<void> : public true_type {};
template <typename _Tp>
struct is_void
: public __is_void_helper<typename remove_cv<_Tp>::type>::type {};
template <typename> struct __is_integral_helper : public false_type {};
template <> struct __is_integral_helper<bool> : public true_type {};
template <> struct __is_integral_helper<char> : public true_type {};
template <> struct __is_integral_helper<signed char> : public true_type {};
template <> struct __is_integral_helper<unsigned char> : public true_type {};
template <> struct __is_integral_helper<wchar_t> : public true_type {};
template <> struct __is_integral_helper<char16_t> : public true_type {};
template <> struct __is_integral_helper<char32_t> : public true_type {};
template <> struct __is_integral_helper<short> : public true_type {};
template <> struct __is_integral_helper<unsigned short> : public true_type {};
template <> struct __is_integral_helper<int> : public true_type {};
template <> struct __is_integral_helper<unsigned int> : public true_type {};
template <> struct __is_integral_helper<long> : public true_type {};
template <> struct __is_integral_helper<unsigned long> : public true_type {};
template <> struct __is_integral_helper<long long> : public true_type {};
template <>
struct __is_integral_helper<unsigned long long> : public true_type {};
# 241 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <typename _Tp>
struct is_integral
: public __is_integral_helper<typename remove_cv<_Tp>::type>::type {};
template <typename> struct __is_floating_point_helper : public false_type {};
template <> struct __is_floating_point_helper<float> : public true_type {};
template <> struct __is_floating_point_helper<double> : public true_type {};
template <>
struct __is_floating_point_helper<long double> : public true_type {};
# 269 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <typename _Tp>
struct is_floating_point
: public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type {
};
template <typename> struct is_array : public false_type {};
template <typename _Tp, std::size_t _Size>
struct is_array<_Tp[_Size]> : public true_type {};
template <typename _Tp> struct is_array<_Tp[]> : public true_type {};
template <typename> struct __is_pointer_helper : public false_type {};
template <typename _Tp>
struct __is_pointer_helper<_Tp *> : public true_type {};
template <typename _Tp>
struct is_pointer
: public __is_pointer_helper<typename remove_cv<_Tp>::type>::type {};
template <typename> struct is_lvalue_reference : public false_type {};
template <typename _Tp>
struct is_lvalue_reference<_Tp &> : public true_type {};
template <typename> struct is_rvalue_reference : public false_type {};
template <typename _Tp>
struct is_rvalue_reference<_Tp &&> : public true_type {};
template <typename> struct is_function;
template <typename>
struct __is_member_object_pointer_helper : public false_type {};
template <typename _Tp, typename _Cp>
struct __is_member_object_pointer_helper<
_Tp _Cp::*> : public integral_constant<bool, !is_function<_Tp>::value> {};
template <typename _Tp>
struct is_member_object_pointer : public __is_member_object_pointer_helper<
typename remove_cv<_Tp>::type>::type {};
template <typename>
struct __is_member_function_pointer_helper : public false_type {};
template <typename _Tp, typename _Cp>
struct __is_member_function_pointer_helper<
_Tp _Cp::*> : public integral_constant<bool, is_function<_Tp>::value> {};
template <typename _Tp>
struct is_member_function_pointer
: public __is_member_function_pointer_helper<
typename remove_cv<_Tp>::type>::type {};
template <typename _Tp>
struct is_enum : public integral_constant<bool, __is_enum(_Tp)> {};
template <typename _Tp>
struct is_union : public integral_constant<bool, __is_union(_Tp)> {};
template <typename _Tp>
struct is_class : public integral_constant<bool, __is_class(_Tp)> {};
template <typename> struct is_function : public false_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...)> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) &> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) && > : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......)> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) &> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) && > : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const &> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const && > : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const &> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const && > : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) volatile> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) volatile &> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) volatile && > : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) volatile> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) volatile &> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) volatile && > : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const volatile> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const volatile &> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const volatile && > : public true_type {
};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const volatile> : public true_type {
};
template <typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const
volatile &> : public true_type {};
template <typename _Res, typename... _ArgTypes>
struct is_function<
_Res(_ArgTypes......) const volatile && > : public true_type {};
template <typename> struct __is_null_pointer_helper : public false_type {};
template <>
struct __is_null_pointer_helper<std::nullptr_t> : public true_type {};
template <typename _Tp>
struct is_null_pointer
: public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type {};
template <typename _Tp>
struct __is_nullptr_t : public is_null_pointer<_Tp> {};
template <typename _Tp>
struct is_reference : public __or_<is_lvalue_reference<_Tp>,
is_rvalue_reference<_Tp> >::type {};
template <typename _Tp>
struct is_arithmetic
: public __or_<is_integral<_Tp>, is_floating_point<_Tp> >::type {};
template <typename _Tp>
struct is_fundamental : public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
is_null_pointer<_Tp> >::type {};
template <typename _Tp>
struct is_object : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
is_void<_Tp> > >::type {};
template <typename> struct is_member_pointer;
template <typename _Tp>
struct is_scalar
: public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
is_member_pointer<_Tp>, is_null_pointer<_Tp> >::type {};
template <typename _Tp>
struct is_compound
: public integral_constant<bool, !is_fundamental<_Tp>::value> {};
template <typename _Tp>
struct __is_member_pointer_helper : public false_type {};
template <typename _Tp, typename _Cp>
struct __is_member_pointer_helper<_Tp _Cp::*> : public true_type {};
template <typename _Tp>
struct is_member_pointer
: public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type {
};
template <typename _Tp>
struct __is_referenceable
: public __or_<is_object<_Tp>, is_reference<_Tp> >::type {};
template <typename _Res, typename... _Args>
struct __is_referenceable<_Res(_Args...)> : public true_type {};
template <typename _Res, typename... _Args>
struct __is_referenceable<_Res(_Args......)> : public true_type {};
template <typename> struct is_const : public false_type {};
template <typename _Tp> struct is_const<_Tp const> : public true_type {};
template <typename> struct is_volatile : public false_type {};
template <typename _Tp>
struct is_volatile<_Tp volatile> : public true_type {};
template <typename _Tp>
struct is_trivial : public integral_constant<bool, __is_trivial(_Tp)> {};
template <typename _Tp>
struct is_standard_layout
: public integral_constant<bool, __is_standard_layout(_Tp)> {};
template <typename _Tp>
struct is_pod : public integral_constant<bool, __is_pod(_Tp)> {};
template <typename _Tp>
struct is_literal_type
: public integral_constant<bool, __is_literal_type(_Tp)> {};
template <typename _Tp>
struct is_empty : public integral_constant<bool, __is_empty(_Tp)> {};
template <typename _Tp>
struct is_polymorphic
: public integral_constant<bool, __is_polymorphic(_Tp)> {};
template <typename _Tp>
struct is_abstract : public integral_constant<bool, __is_abstract(_Tp)> {};
template <typename _Tp, bool = is_arithmetic<_Tp>::value>
struct __is_signed_helper : public false_type {};
template <typename _Tp>
struct __is_signed_helper<_Tp, true> : public integral_constant < bool,
_Tp(-1)<_Tp(0)> {};
template <typename _Tp>
struct is_signed : public __is_signed_helper<_Tp>::type {};
template <typename _Tp>
struct is_unsigned
: public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp> > >::type {};
template <typename> struct add_rvalue_reference;
template <typename _Tp>
typename add_rvalue_reference<_Tp>::type declval() noexcept;
template <typename, unsigned = 0> struct extent;
template <typename> struct remove_all_extents;
template <typename _Tp>
struct __is_array_known_bounds
: public integral_constant<bool, (extent<_Tp>::value > 0)> {};
template <typename _Tp>
struct __is_array_unknown_bounds
: public __and_<is_array<_Tp>, __not_<extent<_Tp> > >::type {};
struct __do_is_destructible_impl {
template <typename _Tp, typename = decltype(declval<_Tp &>().~_Tp())>
static true_type __test(int);
template <typename> static false_type __test(...);
};
template <typename _Tp>
struct __is_destructible_impl : public __do_is_destructible_impl {
typedef decltype(__test<_Tp>(0)) type;
};
template <typename _Tp,
bool = __or_<is_void<_Tp>, __is_array_unknown_bounds<_Tp>,
is_function<_Tp> >::value,
bool = __or_<is_reference<_Tp>, is_scalar<_Tp> >::value>
struct __is_destructible_safe;
template <typename _Tp>
struct __is_destructible_safe<
_Tp, false,
false> : public __is_destructible_impl<typename remove_all_extents<_Tp>::
type>::type {};
template <typename _Tp>
struct __is_destructible_safe<_Tp, true, false> : public false_type {};
template <typename _Tp>
struct __is_destructible_safe<_Tp, false, true> : public true_type {};
template <typename _Tp>
struct is_destructible : public __is_destructible_safe<_Tp>::type {};
struct __do_is_nt_destructible_impl {
template <typename _Tp>
static integral_constant<bool, noexcept(declval<_Tp &>().~_Tp())>
__test(int);
template <typename> static false_type __test(...);
};
template <typename _Tp>
struct __is_nt_destructible_impl : public __do_is_nt_destructible_impl {
typedef decltype(__test<_Tp>(0)) type;
};
template <typename _Tp,
bool = __or_<is_void<_Tp>, __is_array_unknown_bounds<_Tp>,
is_function<_Tp> >::value,
bool = __or_<is_reference<_Tp>, is_scalar<_Tp> >::value>
struct __is_nt_destructible_safe;
template <typename _Tp>
struct __is_nt_destructible_safe<
_Tp, false,
false> : public __is_nt_destructible_impl<typename remove_all_extents<_Tp>::
type>::type {};
template <typename _Tp>
struct __is_nt_destructible_safe<_Tp, true, false> : public false_type {};
template <typename _Tp>
struct __is_nt_destructible_safe<_Tp, false, true> : public true_type {};
template <typename _Tp>
struct is_nothrow_destructible : public __is_nt_destructible_safe<_Tp>::type {
};
struct __do_is_default_constructible_impl {
template <typename _Tp, typename = decltype(_Tp())>
static true_type __test(int);
template <typename> static false_type __test(...);
};
template <typename _Tp>
struct __is_default_constructible_impl
: public __do_is_default_constructible_impl {
typedef decltype(__test<_Tp>(0)) type;
};
template <typename _Tp>
struct __is_default_constructible_atom
: public __and_<__not_<is_void<_Tp> >,
__is_default_constructible_impl<_Tp> >::type {};
template <typename _Tp, bool = is_array<_Tp>::value>
struct __is_default_constructible_safe;
template <typename _Tp>
struct __is_default_constructible_safe<
_Tp, true> : public __and_<__is_array_known_bounds<_Tp>,
__is_default_constructible_atom<
typename remove_all_extents<_Tp>::type> >::
type {};
template <typename _Tp>
struct __is_default_constructible_safe<
_Tp, false> : public __is_default_constructible_atom<_Tp>::type {};
template <typename _Tp>
struct is_default_constructible
: public __is_default_constructible_safe<_Tp>::type {};
# 838 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
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, typename> static false_type __test(...);
};
template <typename _From, typename _To>
struct __is_static_castable_impl : public __do_is_static_castable_impl {
typedef decltype(__test<_From, _To>(0)) type;
};
template <typename _From, typename _To>
struct __is_static_castable_safe
: public __is_static_castable_impl<_From, _To>::type {};
template <typename _From, typename _To>
struct __is_static_castable
: public integral_constant<
bool, (__is_static_castable_safe<_From, _To>::value)> {};
struct __do_is_direct_constructible_impl {
template <typename _Tp, typename _Arg,
typename = decltype(::new _Tp(declval<_Arg>()))>
static true_type __test(int);
template <typename, typename> static false_type __test(...);
};
template <typename _Tp, typename _Arg>
struct __is_direct_constructible_impl
: public __do_is_direct_constructible_impl {
typedef decltype(__test<_Tp, _Arg>(0)) type;
};
template <typename _Tp, typename _Arg>
struct __is_direct_constructible_new_safe
: public __and_<is_destructible<_Tp>,
__is_direct_constructible_impl<_Tp, _Arg> >::type {};
template <typename, typename> struct is_same;
template <typename, typename> struct is_base_of;
template <typename> struct remove_reference;
template <typename _From, typename _To,
bool = __not_<__or_<is_void<_From>, is_function<_From> > >::value>
struct __is_base_to_derived_ref;
template <typename _From, typename _To>
struct __is_base_to_derived_ref<_From, _To, true> {
typedef typename remove_cv<typename remove_reference<_From>::type>::type
__src_t;
typedef typename remove_cv<typename remove_reference<_To>::type>::type
__dst_t;
typedef __and_<__not_<is_same<__src_t, __dst_t> >,
is_base_of<__src_t, __dst_t> > type;
static constexpr bool value = type::value;
};
template <typename _From, typename _To>
struct __is_base_to_derived_ref<_From, _To, false> : public false_type {};
template <typename _From, typename _To,
bool = __and_<is_lvalue_reference<_From>,
is_rvalue_reference<_To> >::value>
struct __is_lvalue_to_rvalue_ref;
template <typename _From, typename _To>
struct __is_lvalue_to_rvalue_ref<_From, _To, true> {
typedef typename remove_cv<typename remove_reference<_From>::type>::type
__src_t;
typedef typename remove_cv<typename remove_reference<_To>::type>::type
__dst_t;
typedef __and_<
__not_<is_function<__src_t> >,
__or_<is_same<__src_t, __dst_t>, is_base_of<__dst_t, __src_t> > > type;
static constexpr bool value = type::value;
};
template <typename _From, typename _To>
struct __is_lvalue_to_rvalue_ref<_From, _To, false> : public false_type {};
template <typename _Tp, typename _Arg>
struct __is_direct_constructible_ref_cast
: public __and_<
__is_static_castable<_Arg, _Tp>,
__not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>,
__is_lvalue_to_rvalue_ref<_Arg, _Tp> > > >::type {};
template <typename _Tp, typename _Arg>
struct __is_direct_constructible_new
: public conditional<
is_reference<_Tp>::value,
__is_direct_constructible_ref_cast<_Tp, _Arg>,
__is_direct_constructible_new_safe<_Tp, _Arg> >::type {};
template <typename _Tp, typename _Arg>
struct __is_direct_constructible
: public __is_direct_constructible_new<_Tp, _Arg>::type {};
struct __do_is_nary_constructible_impl {
template <typename _Tp, typename... _Args,
typename = decltype(_Tp(declval<_Args>()...))>
static true_type __test(int);
template <typename, typename...> static false_type __test(...);
};
template <typename _Tp, typename... _Args>
struct __is_nary_constructible_impl : public __do_is_nary_constructible_impl {
typedef decltype(__test<_Tp, _Args...>(0)) type;
};
template <typename _Tp, typename... _Args>
struct __is_nary_constructible
: public __is_nary_constructible_impl<_Tp, _Args...>::type {
static_assert(sizeof...(_Args) > 1, "Only useful for > 1 arguments");
};
template <typename _Tp, typename... _Args>
struct __is_constructible_impl
: public __is_nary_constructible<_Tp, _Args...> {};
template <typename _Tp, typename _Arg>
struct __is_constructible_impl<_Tp, _Arg> : public __is_direct_constructible<
_Tp, _Arg> {};
template <typename _Tp>
struct __is_constructible_impl<_Tp> : public is_default_constructible<_Tp> {};
template <typename _Tp, typename... _Args>
struct is_constructible
: public __is_constructible_impl<_Tp, _Args...>::type {};
template <typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_copy_constructible_impl;
template <typename _Tp>
struct __is_copy_constructible_impl<_Tp, false> : public false_type {};
template <typename _Tp>
struct __is_copy_constructible_impl<_Tp, true> : public is_constructible<
_Tp, const _Tp &> {};
template <typename _Tp>
struct is_copy_constructible : public __is_copy_constructible_impl<_Tp> {};
template <typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_move_constructible_impl;
template <typename _Tp>
struct __is_move_constructible_impl<_Tp, false> : public false_type {};
template <typename _Tp>
struct __is_move_constructible_impl<_Tp, true> : public is_constructible<
_Tp, _Tp &&> {};
template <typename _Tp>
struct is_move_constructible : public __is_move_constructible_impl<_Tp> {};
template <typename _Tp>
struct __is_nt_default_constructible_atom
: public integral_constant<bool, noexcept(_Tp())> {};
template <typename _Tp, bool = is_array<_Tp>::value>
struct __is_nt_default_constructible_impl;
template <typename _Tp>
struct __is_nt_default_constructible_impl<
_Tp, true> : public __and_<__is_array_known_bounds<_Tp>,
__is_nt_default_constructible_atom<
typename remove_all_extents<_Tp>::type> >::
type {};
template <typename _Tp>
struct __is_nt_default_constructible_impl<
_Tp, false> : public __is_nt_default_constructible_atom<_Tp> {};
template <typename _Tp>
struct is_nothrow_default_constructible
: public __and_<is_default_constructible<_Tp>,
__is_nt_default_constructible_impl<_Tp> >::type {};
template <typename _Tp, typename... _Args>
struct __is_nt_constructible_impl
: public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))> {};
template <typename _Tp, typename _Arg>
struct __is_nt_constructible_impl<_Tp, _Arg> : public integral_constant<
bool,
noexcept(static_cast<_Tp>(
declval<_Arg>()))> {};
template <typename _Tp>
struct __is_nt_constructible_impl<
_Tp> : public is_nothrow_default_constructible<_Tp> {};
template <typename _Tp, typename... _Args>
struct is_nothrow_constructible
: public __and_<is_constructible<_Tp, _Args...>,
__is_nt_constructible_impl<_Tp, _Args...> >::type {};
template <typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nothrow_copy_constructible_impl;
template <typename _Tp>
struct __is_nothrow_copy_constructible_impl<_Tp, false> : public false_type {
};
template <typename _Tp>
struct __is_nothrow_copy_constructible_impl<
_Tp, true> : public is_nothrow_constructible<_Tp, const _Tp &> {};
template <typename _Tp>
struct is_nothrow_copy_constructible
: public __is_nothrow_copy_constructible_impl<_Tp> {};
template <typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nothrow_move_constructible_impl;
template <typename _Tp>
struct __is_nothrow_move_constructible_impl<_Tp, false> : public false_type {
};
template <typename _Tp>
struct __is_nothrow_move_constructible_impl<
_Tp, true> : public is_nothrow_constructible<_Tp, _Tp &&> {};
template <typename _Tp>
struct is_nothrow_move_constructible
: public __is_nothrow_move_constructible_impl<_Tp> {};
template <typename _Tp, typename _Up> class __is_assignable_helper {
template <typename _Tp1, typename _Up1,
typename = decltype(declval<_Tp1>() = declval<_Up1>())>
static true_type __test(int);
template <typename, typename> static false_type __test(...);
public:
typedef decltype(__test<_Tp, _Up>(0)) type;
};
template <typename _Tp, typename _Up>
struct is_assignable : public __is_assignable_helper<_Tp, _Up>::type {};
template <typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_copy_assignable_impl;
template <typename _Tp>
struct __is_copy_assignable_impl<_Tp, false> : public false_type {};
template <typename _Tp>
struct __is_copy_assignable_impl<_Tp, true> : public is_assignable<
_Tp &, const _Tp &> {};
template <typename _Tp>
struct is_copy_assignable : public __is_copy_assignable_impl<_Tp> {};
template <typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_move_assignable_impl;
template <typename _Tp>
struct __is_move_assignable_impl<_Tp, false> : public false_type {};
template <typename _Tp>
struct __is_move_assignable_impl<_Tp, true> : public is_assignable<_Tp &,
_Tp &&> {};
template <typename _Tp>
struct is_move_assignable : public __is_move_assignable_impl<_Tp> {};
template <typename _Tp, typename _Up>
struct __is_nt_assignable_impl
: public integral_constant<bool,
noexcept(declval<_Tp>() = declval<_Up>())> {};
template <typename _Tp, typename _Up>
struct is_nothrow_assignable
: public __and_<is_assignable<_Tp, _Up>,
__is_nt_assignable_impl<_Tp, _Up> >::type {};
template <typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nt_copy_assignable_impl;
template <typename _Tp>
struct __is_nt_copy_assignable_impl<_Tp, false> : public false_type {};
template <typename _Tp>
struct __is_nt_copy_assignable_impl<_Tp, true> : public is_nothrow_assignable<
_Tp &, const _Tp &> {};
template <typename _Tp>
struct is_nothrow_copy_assignable : public __is_nt_copy_assignable_impl<_Tp> {
};
template <typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __is_nt_move_assignable_impl;
template <typename _Tp>
struct __is_nt_move_assignable_impl<_Tp, false> : public false_type {};
template <typename _Tp>
struct __is_nt_move_assignable_impl<_Tp, true> : public is_nothrow_assignable<
_Tp &, _Tp &&> {};
template <typename _Tp>
struct is_nothrow_move_assignable : public __is_nt_move_assignable_impl<_Tp> {
};
# 1274 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <typename _Tp>
struct is_trivially_destructible
: public __and_<
is_destructible<_Tp>,
integral_constant<bool, __has_trivial_destructor(_Tp)> >::type {};
template <typename _Tp>
struct has_trivial_default_constructor
: public integral_constant<bool, __has_trivial_constructor(_Tp)> {};
template <typename _Tp>
struct has_trivial_copy_constructor
: public integral_constant<bool, __has_trivial_copy(_Tp)> {};
template <typename _Tp>
struct has_trivial_copy_assign
: public integral_constant<bool, __has_trivial_assign(_Tp)> {};
template <typename _Tp>
struct has_virtual_destructor
: public integral_constant<bool, __has_virtual_destructor(_Tp)> {};
template <typename _Tp>
struct alignment_of
: public integral_constant<std::size_t, __alignof__(_Tp)> {};
template <typename> struct rank : public integral_constant<std::size_t, 0> {};
template <typename _Tp, std::size_t _Size>
struct rank<_Tp[_Size]> : public integral_constant<std::size_t,
1 + rank<_Tp>::value> {};
template <typename _Tp>
struct rank<_Tp[]> : public integral_constant<std::size_t,
1 + rank<_Tp>::value> {};
template <typename, unsigned _Uint>
struct extent : public integral_constant<std::size_t, 0> {};
template <typename _Tp, unsigned _Uint, std::size_t _Size>
struct extent<_Tp[_Size], _Uint> : public integral_constant < std::size_t,
_Uint == 0 ? _Size : extent<_Tp, _Uint - 1>::value > {};
template <typename _Tp, unsigned _Uint>
struct extent<_Tp[], _Uint> : public integral_constant < std::size_t,
_Uint == 0 ? 0 : extent<_Tp, _Uint - 1>::value > {};
template <typename, typename> struct is_same : public false_type {};
template <typename _Tp> struct is_same<_Tp, _Tp> : public true_type {};
template <typename _Base, typename _Derived>
struct is_base_of
: public integral_constant<bool, __is_base_of(_Base, _Derived)> {};
template <typename _From, typename _To,
bool =
__or_<is_void<_From>, is_function<_To>, is_array<_To> >::value>
struct __is_convertible_helper {
typedef typename is_void<_To>::type type;
};
template <typename _From, typename _To>
class __is_convertible_helper<_From, _To, false> {
template <typename _To1> static void __test_aux(_To1);
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(...);
public:
typedef decltype(__test<_From, _To>(0)) type;
};
template <typename _From, typename _To>
struct is_convertible : public __is_convertible_helper<_From, _To>::type {};
template <typename _Tp> struct remove_const {
typedef _Tp type;
};
template <typename _Tp> struct remove_const<_Tp const> {
typedef _Tp type;
};
template <typename _Tp> struct remove_volatile {
typedef _Tp type;
};
template <typename _Tp> struct remove_volatile<_Tp volatile> {
typedef _Tp type;
};
template <typename _Tp> struct remove_cv {
typedef typename remove_const<typename remove_volatile<_Tp>::type>::type
type;
};
template <typename _Tp> struct add_const {
typedef _Tp const type;
};
template <typename _Tp> struct add_volatile {
typedef _Tp volatile type;
};
template <typename _Tp> struct add_cv {
typedef typename add_const<typename add_volatile<_Tp>::type>::type type;
};
# 1470 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <typename _Tp> struct remove_reference {
typedef _Tp type;
};
template <typename _Tp> struct remove_reference<_Tp &> {
typedef _Tp type;
};
template <typename _Tp> struct remove_reference<_Tp &&> {
typedef _Tp type;
};
template <typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __add_lvalue_reference_helper {
typedef _Tp type;
};
template <typename _Tp> struct __add_lvalue_reference_helper<_Tp, true> {
typedef _Tp &type;
};
template <typename _Tp>
struct add_lvalue_reference : public __add_lvalue_reference_helper<_Tp> {};
template <typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __add_rvalue_reference_helper {
typedef _Tp type;
};
template <typename _Tp> struct __add_rvalue_reference_helper<_Tp, true> {
typedef _Tp &&type;
};
template <typename _Tp>
struct add_rvalue_reference : public __add_rvalue_reference_helper<_Tp> {};
# 1527 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <typename _Unqualified, bool _IsConst, bool _IsVol>
struct __cv_selector;
template <typename _Unqualified>
struct __cv_selector<_Unqualified, false, false> {
typedef _Unqualified __type;
};
template <typename _Unqualified>
struct __cv_selector<_Unqualified, false, true> {
typedef volatile _Unqualified __type;
};
template <typename _Unqualified>
struct __cv_selector<_Unqualified, true, false> {
typedef const _Unqualified __type;
};
template <typename _Unqualified>
struct __cv_selector<_Unqualified, true, true> {
typedef const volatile _Unqualified __type;
};
template <typename _Qualified, typename _Unqualified,
bool _IsConst = is_const<_Qualified>::value,
bool _IsVol = is_volatile<_Qualified>::value>
class __match_cv_qualifiers {
typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
public:
typedef typename __match::__type __type;
};
template <typename _Tp> struct __make_unsigned {
typedef _Tp __type;
};
template <> struct __make_unsigned<char> {
typedef unsigned char __type;
};
template <> struct __make_unsigned<signed char> {
typedef unsigned char __type;
};
template <> struct __make_unsigned<short> {
typedef unsigned short __type;
};
template <> struct __make_unsigned<int> {
typedef unsigned int __type;
};
template <> struct __make_unsigned<long> {
typedef unsigned long __type;
};
template <> struct __make_unsigned<long long> {
typedef unsigned long long __type;
};
# 1593 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <typename _Tp, bool _IsInt = is_integral<_Tp>::value,
bool _IsEnum = is_enum<_Tp>::value>
class __make_unsigned_selector;
template <typename _Tp> class __make_unsigned_selector<_Tp, true, false> {
typedef __make_unsigned<typename remove_cv<_Tp>::type> __unsignedt;
typedef typename __unsignedt::__type __unsigned_type;
typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
public:
typedef typename __cv_unsigned::__type __type;
};
template <typename _Tp> class __make_unsigned_selector<_Tp, false, true> {
typedef unsigned char __smallest;
static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short);
static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int);
typedef conditional<__b2, unsigned int, unsigned long> __cond2;
typedef typename __cond2::type __cond2_type;
typedef conditional<__b1, unsigned short, __cond2_type> __cond1;
typedef typename __cond1::type __cond1_type;
public:
typedef typename conditional<__b0, __smallest, __cond1_type>::type __type;
};
template <typename _Tp> struct make_unsigned {
typedef typename __make_unsigned_selector<_Tp>::__type type;
};
template <> struct make_unsigned<bool>;
template <typename _Tp> struct __make_signed {
typedef _Tp __type;
};
template <> struct __make_signed<char> {
typedef signed char __type;
};
template <> struct __make_signed<unsigned char> {
typedef signed char __type;
};
template <> struct __make_signed<unsigned short> {
typedef signed short __type;
};
template <> struct __make_signed<unsigned int> {
typedef signed int __type;
};
template <> struct __make_signed<unsigned long> {
typedef signed long __type;
};
template <> struct __make_signed<unsigned long long> {
typedef signed long long __type;
};
# 1675 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <typename _Tp, bool _IsInt = is_integral<_Tp>::value,
bool _IsEnum = is_enum<_Tp>::value>
class __make_signed_selector;
template <typename _Tp> class __make_signed_selector<_Tp, true, false> {
typedef __make_signed<typename remove_cv<_Tp>::type> __signedt;
typedef typename __signedt::__type __signed_type;
typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed;
public:
typedef typename __cv_signed::__type __type;
};
template <typename _Tp> class __make_signed_selector<_Tp, false, true> {
typedef signed char __smallest;
static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
static const bool __b1 = sizeof(_Tp) <= sizeof(signed short);
static const bool __b2 = sizeof(_Tp) <= sizeof(signed int);
typedef conditional<__b2, signed int, signed long> __cond2;
typedef typename __cond2::type __cond2_type;
typedef conditional<__b1, signed short, __cond2_type> __cond1;
typedef typename __cond1::type __cond1_type;
public:
typedef typename conditional<__b0, __smallest, __cond1_type>::type __type;
};
template <typename _Tp> struct make_signed {
typedef typename __make_signed_selector<_Tp>::__type type;
};
template <> struct make_signed<bool>;
# 1733 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <typename _Tp> struct remove_extent {
typedef _Tp type;
};
template <typename _Tp, std::size_t _Size> struct remove_extent<_Tp[_Size]> {
typedef _Tp type;
};
template <typename _Tp> struct remove_extent<_Tp[]> {
typedef _Tp type;
};
template <typename _Tp> struct remove_all_extents {
typedef _Tp type;
};
template <typename _Tp, std::size_t _Size>
struct remove_all_extents<_Tp[_Size]> {
typedef typename remove_all_extents<_Tp>::type type;
};
template <typename _Tp> struct remove_all_extents<_Tp[]> {
typedef typename remove_all_extents<_Tp>::type type;
};
# 1770 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <typename _Tp, typename> struct __remove_pointer_helper {
typedef _Tp type;
};
template <typename _Tp, typename _Up>
struct __remove_pointer_helper<_Tp, _Up *> {
typedef _Up type;
};
template <typename _Tp>
struct remove_pointer
: public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type> {};
template <typename _Tp,
bool = __or_<__is_referenceable<_Tp>, is_void<_Tp> >::value>
struct __add_pointer_helper {
typedef _Tp type;
};
template <typename _Tp> struct __add_pointer_helper<_Tp, true> {
typedef typename remove_reference<_Tp>::type *type;
};
template <typename _Tp>
struct add_pointer : public __add_pointer_helper<_Tp> {};
# 1809 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <std::size_t _Len> struct __aligned_storage_msa {
union __type {
unsigned char __data[_Len];
struct __attribute__((__aligned__)) {
} __align;
};
};
# 1829 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
template <std::size_t _Len, std::size_t _Align = __alignof__(
typename __aligned_storage_msa<_Len>::__type)>
struct aligned_storage {
union type {
unsigned char __data[_Len];
struct __attribute__((__aligned__((_Align)))) {
} __align;
};
};
template <typename _Up, bool _IsArray = is_array<_Up>::value,
bool _IsFunction = is_function<_Up>::value>
struct __decay_selector;
template <typename _Up> struct __decay_selector<_Up, false, false> {
typedef typename remove_cv<_Up>::type __type;
};
template <typename _Up> struct __decay_selector<_Up, true, false> {
typedef typename remove_extent<_Up>::type *__type;
};
template <typename _Up> struct __decay_selector<_Up, false, true> {
typedef typename add_pointer<_Up>::type __type;
};
template <typename _Tp> class decay {
typedef typename remove_reference<_Tp>::type __remove_type;
public:
typedef typename __decay_selector<__remove_type>::__type type;
};
template <typename _Tp> class reference_wrapper;
template <typename _Tp> struct __strip_reference_wrapper {
typedef _Tp __type;
};
template <typename _Tp>
struct __strip_reference_wrapper<reference_wrapper<_Tp> > {
typedef _Tp &__type;
};
template <typename _Tp> struct __decay_and_strip {
typedef typename __strip_reference_wrapper<
typename decay<_Tp>::type>::__type __type;
};
template <bool, typename _Tp = void> struct enable_if {};
template <typename _Tp> struct enable_if<true, _Tp> {
typedef _Tp type;
};
template <typename... _Cond>
using _Require = typename enable_if<__and_<_Cond...>::value>::type;
template <bool _Cond, 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> struct common_type;
struct __do_common_type_impl {
template <typename _Tp, typename _Up>
static __success_type<typename decay<
decltype(true ? std::declval<_Tp>() : std::declval<_Up>())>::type>
_S_test(int);
template <typename, typename> static __failure_type _S_test(...);
};
template <typename _Tp, typename _Up>
struct __common_type_impl : private __do_common_type_impl {
typedef decltype(_S_test<_Tp, _Up>(0)) type;
};
struct __do_member_type_wrapper {
template <typename _Tp>
static __success_type<typename _Tp::type> _S_test(int);
template <typename> static __failure_type _S_test(...);
};
template <typename _Tp>
struct __member_type_wrapper : private __do_member_type_wrapper {
typedef decltype(_S_test<_Tp>(0)) type;
};
template <typename _CTp, typename... _Args>
struct __expanded_common_type_wrapper {
typedef common_type<typename _CTp::type, _Args...> type;
};
template <typename... _Args>
struct __expanded_common_type_wrapper<__failure_type, _Args...> {
typedef __failure_type type;
};
template <typename _Tp> struct common_type<_Tp> {
typedef typename decay<_Tp>::type type;
};
template <typename _Tp, typename _Up>
struct common_type<_Tp, _Up> : public __common_type_impl<_Tp, _Up>::type {};
template <typename _Tp, typename _Up, typename... _Vp>
struct common_type<_Tp, _Up, _Vp...> : public __expanded_common_type_wrapper<
typename __member_type_wrapper<
common_type<_Tp, _Up> >::type,
_Vp...>::type {};
template <typename _Tp> struct underlying_type {
typedef __underlying_type(_Tp) type;
};
template <typename _Tp> struct __declval_protector {
static const bool __stop = false;
static typename add_rvalue_reference<_Tp>::type __delegate();
};
template <typename _Tp>
inline typename add_rvalue_reference<_Tp>::type declval() noexcept {
static_assert(__declval_protector<_Tp>::__stop,
"declval() must not be used!");
return __declval_protector<_Tp>::__delegate();
}
template <typename _Signature> class result_of;
struct __result_of_memfun_ref_impl {
template <typename _Fp, typename _Tp1, typename... _Args>
static __success_type<decltype(
(std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...))>
_S_test(int);
template <typename...> static __failure_type _S_test(...);
};
template <typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_memfun_ref : private __result_of_memfun_ref_impl {
typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
};
struct __result_of_memfun_deref_impl {
template <typename _Fp, typename _Tp1, typename... _Args>
static __success_type<
decltype(((*std::declval<_Tp1>()).*
std::declval<_Fp>())(std::declval<_Args>()...))>
_S_test(int);
template <typename...> static __failure_type _S_test(...);
};
template <typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_memfun_deref : private __result_of_memfun_deref_impl {
typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
};
struct __result_of_memobj_ref_impl {
template <typename _Fp, typename _Tp1>
static __success_type<decltype(std::declval<_Tp1>().*std::declval<_Fp>())>
_S_test(int);
template <typename, typename> static __failure_type _S_test(...);
};
template <typename _MemPtr, typename _Arg>
struct __result_of_memobj_ref : private __result_of_memobj_ref_impl {
typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
};
struct __result_of_memobj_deref_impl {
template <typename _Fp, typename _Tp1>
static __success_type<
decltype((*std::declval<_Tp1>()).*std::declval<_Fp>())>
_S_test(int);
template <typename, typename> static __failure_type _S_test(...);
};
template <typename _MemPtr, typename _Arg>
struct __result_of_memobj_deref : private __result_of_memobj_deref_impl {
typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
};
template <typename _MemPtr, typename _Arg> struct __result_of_memobj;
template <typename _Res, typename _Class, typename _Arg>
struct __result_of_memobj<_Res _Class::*, _Arg> {
typedef typename remove_cv<typename remove_reference<_Arg>::type>::type
_Argval;
typedef _Res _Class::*_MemPtr;
typedef typename conditional<
__or_<is_same<_Argval, _Class>, is_base_of<_Class, _Argval> >::value,
__result_of_memobj_ref<_MemPtr, _Arg>,
__result_of_memobj_deref<_MemPtr, _Arg> >::type::type type;
};
template <typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_memfun;
template <typename _Res, typename _Class, typename _Arg, typename... _Args>
struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> {
typedef typename remove_cv<typename remove_reference<_Arg>::type>::type
_Argval;
typedef _Res _Class::*_MemPtr;
typedef typename conditional<
__or_<is_same<_Argval, _Class>, is_base_of<_Class, _Argval> >::value,
__result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
__result_of_memfun_deref<_MemPtr, _Arg, _Args...> >::type::type type;
};
template <bool, bool, typename _Functor, typename... _ArgTypes>
struct __result_of_impl {
typedef __failure_type type;
};
template <typename _MemPtr, typename _Arg>
struct __result_of_impl<
true, false, _MemPtr,
_Arg> : public __result_of_memobj<typename decay<_MemPtr>::type, _Arg> {};
template <typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_impl<
false, true, _MemPtr, _Arg,
_Args...> : public __result_of_memfun<typename decay<_MemPtr>::type, _Arg,
_Args...> {};
struct __result_of_other_impl {
template <typename _Fn, typename... _Args>
static __success_type<
decltype(std::declval<_Fn>()(std::declval<_Args>()...))>
_S_test(int);
template <typename...> static __failure_type _S_test(...);
};
template <typename _Functor, typename... _ArgTypes>
struct __result_of_impl<false, false, _Functor,
_ArgTypes...> : private __result_of_other_impl {
typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
};
template <typename _Functor, typename... _ArgTypes>
struct result_of<_Functor(_ArgTypes...)> : public __result_of_impl<
is_member_object_pointer<
typename remove_reference<
_Functor>::type>::
value,
is_member_function_pointer<
typename remove_reference<
_Functor>::type>::
value,
_Functor,
_ArgTypes...>::type {};
# 2232 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/type_traits" 3
}
# 58 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/move.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
# 74 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/move.h" 3
template <typename _Tp>
constexpr _Tp &&forward(typename std::remove_reference<_Tp>::type &
__t) noexcept {
return static_cast<_Tp &&>(__t);
}
template <typename _Tp>
constexpr _Tp &&forward(typename std::remove_reference<_Tp>::type &&
__t) noexcept {
static_assert(!std::is_lvalue_reference<_Tp>::value,
"template argument"
" substituting _Tp is an lvalue reference type");
return static_cast<_Tp &&>(__t);
}
template <typename _Tp>
constexpr typename std::remove_reference<_Tp>::type &&move(_Tp &&
__t) noexcept {
return static_cast<typename std::remove_reference<_Tp>::type &&>(__t);
}
template <typename _Tp>
struct __move_if_noexcept_cond
: public __and_<__not_<is_nothrow_move_constructible<_Tp> >,
is_copy_constructible<_Tp> >::type {};
# 118 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/move.h" 3
template <typename _Tp>
constexpr typename conditional<__move_if_noexcept_cond<_Tp>::value,
const _Tp &, _Tp &&>::type
move_if_noexcept(_Tp & __x) noexcept {
return std::move(__x);
}
# 133 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/move.h" 3
template <typename _Tp> inline _Tp *addressof(_Tp & __r) noexcept {
return std::__addressof(__r);
}
}
# 149 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/move.h" 3
namespace std __attribute__((__visibility__("default"))) {
# 164 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/move.h" 3
template <typename _Tp>
inline void swap(_Tp & __a, _Tp & __b) noexcept(
__and_<is_nothrow_move_constructible<_Tp>,
is_nothrow_move_assignable<_Tp> >::value) {
_Tp __tmp = std::move(__a);
__a = std::move(__b);
__b = std::move(__tmp);
}
template <typename _Tp, size_t _Nm>
inline void swap(_Tp(&__a)[_Nm],
_Tp(&__b)[_Nm]) noexcept(noexcept(swap(*__a, *__b))) {
for (size_t __n = 0; __n < _Nm; ++__n)
swap(__a[__n], __b[__n]);
}
}
# 60 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_pair.h" 2 3
namespace std __attribute__((__visibility__("default"))) {
# 76 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_pair.h" 3
struct piecewise_construct_t {};
constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
template <typename...> class tuple;
template <std::size_t...> struct _Index_tuple;
# 95 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_pair.h" 3
template <class _T1, class _T2> struct pair {
typedef _T1 first_type;
typedef _T2 second_type;
_T1 first;
_T2 second;
constexpr pair() : first(), second() {}
constexpr pair(const _T1 &__a, const _T2 &__b) : first(__a), second(__b) {}
template <class _U1, class _U2,
class = typename enable_if<
__and_<is_convertible<const _U1 &, _T1>,
is_convertible<const _U2 &, _T2> >::value>::type>
constexpr pair(const pair<_U1, _U2> &__p)
: first(__p.first), second(__p.second) {}
constexpr pair(const pair &) = default;
constexpr pair(pair &&) = default;
template <class _U1,
class = typename enable_if<is_convertible<_U1, _T1>::value>::type>
constexpr pair(_U1 &&__x, const _T2 &__y)
: first(std::forward<_U1>(__x)), second(__y) {}
template <class _U2,
class = typename enable_if<is_convertible<_U2, _T2>::value>::type>
constexpr pair(const _T1 &__x, _U2 &&__y)
: first(__x), second(std::forward<_U2>(__y)) {}
template <
class _U1, class _U2,
class = typename enable_if<__and_<
is_convertible<_U1, _T1>, is_convertible<_U2, _T2> >::value>::type>
constexpr pair(_U1 &&__x, _U2 &&__y)
: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) {}
template <
class _U1, class _U2,
class = typename enable_if<__and_<
is_convertible<_U1, _T1>, is_convertible<_U2, _T2> >::value>::type>
constexpr pair(pair<_U1, _U2> &&__p)
: first(std::forward<_U1>(__p.first)),
second(std::forward<_U2>(__p.second)) {}
template <typename... _Args1, typename... _Args2>
pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);
pair &operator=(const pair &__p) {
first = __p.first;
second = __p.second;
return *this;
}
pair &operator=(pair &&__p) noexcept(
__and_<is_nothrow_move_assignable<_T1>,
is_nothrow_move_assignable<_T2> >::value) {
first = std::forward<first_type>(__p.first);
second = std::forward<second_type>(__p.second);
return *this;
}
template <class _U1, class _U2> pair &operator=(const pair<_U1, _U2> &__p) {
first = __p.first;
second = __p.second;
return *this;
}
template <class _U1, class _U2> pair &operator=(pair<_U1, _U2> &&__p) {
first = std::forward<_U1>(__p.first);
second = std::forward<_U2>(__p.second);
return *this;
}
void swap(pair &__p) noexcept(noexcept(swap(first, __p.first)) &&
noexcept(swap(second, __p.second))) {
using std::swap;
swap(first, __p.first);
swap(second, __p.second);
}
private:
template <typename... _Args1, std::size_t... _Indexes1, typename... _Args2,
std::size_t... _Indexes2>
pair(tuple<_Args1...> &, tuple<_Args2...> &, _Index_tuple<_Indexes1...>,
_Index_tuple<_Indexes2...>);
};
template <class _T1, class _T2>
inline constexpr bool operator==(const pair<_T1, _T2> & __x,
const pair<_T1, _T2> & __y) {
return __x.first == __y.first && __x.second == __y.second;
}
template <class _T1, class _T2>
inline constexpr bool operator<(const pair<_T1, _T2> & __x,
const pair<_T1, _T2> & __y) {
return __x.first < __y.first ||
(!(__y.first < __x.first) && __x.second < __y.second);
}
template <class _T1, class _T2>
inline constexpr bool operator!=(const pair<_T1, _T2> & __x,
const pair<_T1, _T2> & __y) {
return !(__x == __y);
}
template <class _T1, class _T2>
inline constexpr bool operator>(const pair<_T1, _T2> & __x,
const pair<_T1, _T2> & __y) {
return __y < __x;
}
template <class _T1, class _T2>
inline constexpr bool operator<=(const pair<_T1, _T2> & __x,
const pair<_T1, _T2> & __y) {
return !(__y < __x);
}
template <class _T1, class _T2>
inline constexpr bool operator>=(const pair<_T1, _T2> & __x,
const pair<_T1, _T2> & __y) {
return !(__x < __y);
}
template <class _T1, class _T2>
inline void swap(pair<_T1, _T2> & __x,
pair<_T1, _T2> & __y) noexcept(noexcept(__x.swap(__y))) {
__x.swap(__y);
}
# 273 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_pair.h" 3
template <class _T1, class _T2>
constexpr pair<typename __decay_and_strip<_T1>::__type,
typename __decay_and_strip<_T2>::__type> make_pair(_T1 && __x,
_T2 &&
__y) {
typedef typename __decay_and_strip<_T1>::__type __ds_type1;
typedef typename __decay_and_strip<_T2>::__type __ds_type2;
typedef pair<__ds_type1, __ds_type2> __pair_type;
return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
}
# 293 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/bits/stl_pair.h" 3
}
# 71 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/utility" 2 3
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/initializer_list" 1 3
# 34 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/initializer_list" 3
#pragma GCC visibility push(default)
namespace std {
template <class _E> class initializer_list {
public:
typedef _E value_type;
typedef const _E &reference;
typedef const _E &const_reference;
typedef size_t size_type;
typedef const _E *iterator;
typedef const _E *const_iterator;
private:
iterator _M_array;
size_type _M_len;
constexpr initializer_list(const_iterator __a, size_type __l)
: _M_array(__a), _M_len(__l) {}
public:
constexpr initializer_list() noexcept : _M_array(0), _M_len(0) {}
constexpr size_type size() const noexcept { return _M_len; }
constexpr const_iterator begin() const noexcept { return _M_array; }
constexpr const_iterator end() const noexcept { return begin() + size(); }
};
template <class _Tp>
constexpr const _Tp *begin(initializer_list<_Tp> __ils) noexcept {
return __ils.begin();
}
template <class _Tp>
constexpr const _Tp *end(initializer_list<_Tp> __ils) noexcept {
return __ils.end();
}
}
#pragma GCC visibility pop
# 75 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/utility" 2 3
namespace std __attribute__((__visibility__("default"))) {
template <class _Tp> class tuple_size;
template <std::size_t _Int, class _Tp> class tuple_element;
template <class _Tp1, class _Tp2>
struct tuple_size<std::pair<_Tp1, _Tp2> > : public integral_constant<
std::size_t, 2> {};
template <class _Tp1, class _Tp2>
struct tuple_element<0, std::pair<_Tp1, _Tp2> > {
typedef _Tp1 type;
};
template <class _Tp1, class _Tp2>
struct tuple_element<1, std::pair<_Tp1, _Tp2> > {
typedef _Tp2 type;
};
template <std::size_t _Int> struct __pair_get;
template <> struct __pair_get<0> {
template <typename _Tp1, typename _Tp2>
static constexpr _Tp1 &__get(std::pair<_Tp1, _Tp2> &__pair) noexcept {
return __pair.first;
}
template <typename _Tp1, typename _Tp2>
static constexpr _Tp1 &&
__move_get(std::pair<_Tp1, _Tp2> &&__pair) noexcept {
return std::forward<_Tp1>(__pair.first);
}
template <typename _Tp1, typename _Tp2>
static constexpr const _Tp1 &
__const_get(const std::pair<_Tp1, _Tp2> &__pair) noexcept {
return __pair.first;
}
};
template <> struct __pair_get<1> {
template <typename _Tp1, typename _Tp2>
static constexpr _Tp2 &__get(std::pair<_Tp1, _Tp2> &__pair) noexcept {
return __pair.second;
}
template <typename _Tp1, typename _Tp2>
static constexpr _Tp2 &&
__move_get(std::pair<_Tp1, _Tp2> &&__pair) noexcept {
return std::forward<_Tp2>(__pair.second);
}
template <typename _Tp1, typename _Tp2>
static constexpr const _Tp2 &
__const_get(const std::pair<_Tp1, _Tp2> &__pair) noexcept {
return __pair.second;
}
};
template <std::size_t _Int, class _Tp1, class _Tp2>
constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type &get(
std::pair<_Tp1, _Tp2> & __in) noexcept {
return __pair_get<_Int>::__get(__in);
}
template <std::size_t _Int, class _Tp1, class _Tp2>
constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type &&get(
std::pair<_Tp1, _Tp2> && __in) noexcept {
return __pair_get<_Int>::__move_get(std::move(__in));
}
template <std::size_t _Int, class _Tp1, class _Tp2>
constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type &
get(const std::pair<_Tp1, _Tp2> & __in) noexcept {
return __pair_get<_Int>::__const_get(__in);
}
# 199 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/utility" 3
template <size_t... _Indexes> struct _Index_tuple {
typedef _Index_tuple<_Indexes..., sizeof...(_Indexes)> __next;
};
template <size_t _Num> struct _Build_index_tuple {
typedef typename _Build_index_tuple<_Num - 1>::__type::__next __type;
};
template <> struct _Build_index_tuple<0> {
typedef _Index_tuple<> __type;
};
# 259 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/utility" 3
}
# 5 "./cxx_invoke.hh" 2
namespace cxx {
struct __any {
__any(...);
};
struct __nat {
__nat() = delete;
__nat(const __nat &) = delete;
__nat &operator=(const __nat &) = delete;
~__nat() = delete;
};
template <class _MP, bool _IsMemberFuctionPtr, bool _IsMemberObjectPtr>
struct member_pointer_traits_imp {};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...), true, false> {
typedef _Class class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const, true,
false> {
typedef _Class const class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile, true,
false> {
typedef _Class volatile class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile,
true, false> {
typedef _Class const volatile class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) &, true, false> {
typedef _Class &class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const &, true,
false> {
typedef _Class const &class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile &, true,
false> {
typedef _Class volatile &class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile &,
true, false> {
typedef _Class const volatile &class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) &&, true, false> {
typedef _Class &&class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const &&, true,
false> {
typedef _Class const &&class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile &&, true,
false> {
typedef _Class volatile &&class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class, class... _Param>
struct member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile &&,
true, false> {
typedef _Class const volatile &&class_type;
typedef _Rp return_type;
};
template <class _Rp, class _Class>
struct member_pointer_traits_imp<_Rp _Class::*, false, true> {
typedef _Class class_type;
typedef _Rp return_type;
};
template <class _MP>
struct member_pointer_traits : public member_pointer_traits_imp<
typename std::remove_cv<_MP>::type,
std::is_member_function_pointer<_MP>::value,
std::is_member_object_pointer<_MP>::value> {
};
template <class... _Tp> struct check_complete;
template <> struct check_complete<> {};
template <class _Hp, class _T0, class... _Tp>
struct check_complete<_Hp, _T0, _Tp...> : private check_complete<_Hp>,
private check_complete<_T0, _Tp...> {
};
template <class _Hp>
struct check_complete<_Hp, _Hp> : private check_complete<_Hp> {};
template <class _Tp> struct check_complete<_Tp> {
static_assert(sizeof(_Tp) > 0, "Type must be complete.");
};
template <class _Tp>
struct check_complete<_Tp &> : private check_complete<_Tp> {};
template <class _Tp>
struct check_complete<_Tp &&> : private check_complete<_Tp> {};
template <class _Rp, class... _Param>
struct check_complete<_Rp (*)(_Param...)> : private check_complete<_Rp> {};
template <class... _Param> struct check_complete<void (*)(_Param...)> {};
template <class _Rp, class... _Param>
struct check_complete<_Rp(_Param...)> : private check_complete<_Rp> {};
template <class... _Param> struct check_complete<void(_Param...)> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<_Rp (_Class::*)(_Param...)> : private check_complete<
_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<
_Rp (_Class::*)(_Param...) const> : private check_complete<_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<
_Rp (_Class::*)(_Param...) volatile> : private check_complete<_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<_Rp (_Class::*)(_Param...) const
volatile> : private check_complete<_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<_Rp (_Class::*)(_Param...) &> : private check_complete<
_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<_Rp (_Class::*)(_Param...) const
&> : private check_complete<_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<
_Rp (_Class::*)(_Param...) volatile &> : private check_complete<_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<_Rp (_Class::*)(_Param...) const
volatile &> : private check_complete<_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<_Rp (_Class::*)(_Param...) && > : private check_complete<
_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<_Rp (_Class::*)(_Param...) const
&&> : private check_complete<_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<
_Rp (_Class::*)(_Param...) volatile &&> : private check_complete<_Class> {};
template <class _Rp, class _Class, class... _Param>
struct check_complete<_Rp (_Class::*)(_Param...) const
volatile &&> : private check_complete<_Class> {};
template <class _Rp, class _Class>
struct check_complete<_Rp _Class::*> : private check_complete<_Class> {};
template <class... _Args> auto invoke(__any, _Args &&... __args) -> __nat;
template <
class _Fp, class _A0, class... _Args,
class = typename std::enable_if<
std::is_member_function_pointer<
typename std::remove_reference<_Fp>::type>::value &&
std::is_base_of<
typename member_pointer_traits<
typename std::remove_reference<_Fp>::type>::class_type,
typename std::remove_reference<_A0>::type>::value>::type>
auto invoke(_Fp &&__f, _A0 &&__a0, _Args &&... __args)
-> decltype((std::forward<_A0>(__a0).*__f)(std::forward<_Args>(__args)...));
template <class _Fp, class _A0, class... _Args,
class = typename std::enable_if<
std::is_member_function_pointer<
typename std::remove_reference<_Fp>::type>::value &&
!std::is_base_of<
typename member_pointer_traits<
typename std::remove_reference<_Fp>::type>::class_type,
typename std::remove_reference<_A0>::type>::value>::type>
auto invoke(_Fp &&__f, _A0 &&__a0, _Args &&... __args)
-> decltype(((*std::forward<_A0>(__a0)).*
__f)(std::forward<_Args>(__args)...));
template <
class _Fp, class _A0,
class = typename std::enable_if<
std::is_member_object_pointer<
typename std::remove_reference<_Fp>::type>::value &&
std::is_base_of<
typename member_pointer_traits<
typename std::remove_reference<_Fp>::type>::class_type,
typename std::remove_reference<_A0>::type>::value>::type>
auto invoke(_Fp &&__f, _A0 &&__a0) -> decltype(std::forward<_A0>(__a0).*__f);
template <class _Fp, class _A0,
class = typename std::enable_if<
std::is_member_object_pointer<
typename std::remove_reference<_Fp>::type>::value &&
!std::is_base_of<
typename member_pointer_traits<
typename std::remove_reference<_Fp>::type>::class_type,
typename std::remove_reference<_A0>::type>::value>::type>
auto invoke(_Fp &&__f, _A0 &&__a0) -> decltype((*std::forward<_A0>(__a0)).*__f);
template <class _Fp, class... _Args>
auto invoke(_Fp &&__f, _Args &&... __args)
-> decltype(std::forward<_Fp>(__f)(std::forward<_Args>(__args)...));
template <class _Fp, class... _Args>
struct invokable_imp : private check_complete<_Fp> {
typedef decltype(invoke(std::declval<_Fp>(), std::declval<_Args>()...)) type;
static const bool value = !std::is_same<type, __nat>::value;
};
template <class _Fp, class... _Args>
struct invokable
: public std::integral_constant<bool, invokable_imp<_Fp, _Args...>::value> {
};
template <bool _Invokable, class _Fp, class... _Args> struct invoke_of_imp {};
template <class _Fp, class... _Args> struct invoke_of_imp<true, _Fp, _Args...> {
typedef typename invokable_imp<_Fp, _Args...>::type type;
};
template <class _Fp, class... _Args>
struct invoke_of
: public invoke_of_imp<invokable<_Fp, _Args...>::value, _Fp, _Args...> {};
template <class _Fp, class _A0, class... _Args, class>
inline auto invoke(_Fp &&__f, _A0 &&__a0, _Args &&... __args)
-> decltype((std::forward<_A0>(__a0).*
__f)(std::forward<_Args>(__args)...)) {
return (std::forward<_A0>(__a0).*__f)(std::forward<_Args>(__args)...);
}
template <class _Fp, class _A0, class... _Args, class>
inline auto invoke(_Fp &&__f, _A0 &&__a0, _Args &&... __args)
-> decltype(((*std::forward<_A0>(__a0)).*
__f)(std::forward<_Args>(__args)...)) {
return ((*std::forward<_A0>(__a0)).*__f)(std::forward<_Args>(__args)...);
}
template <class _Fp, class _A0, class>
inline auto invoke(_Fp &&__f, _A0 &&__a0)
-> decltype(std::forward<_A0>(__a0).*__f) {
return std::forward<_A0>(__a0).*__f;
}
template <class _Fp, class _A0, class>
inline auto invoke(_Fp &&__f, _A0 &&__a0)
-> decltype((*std::forward<_A0>(__a0)).*__f) {
return (*std::forward<_A0>(__a0)).*__f;
}
template <class _Fp, class... _Args>
inline auto invoke(_Fp &&__f, _Args &&... __args)
-> decltype(std::forward<_Fp>(__f)(std::forward<_Args>(__args)...)) {
return std::forward<_Fp>(__f)(std::forward<_Args>(__args)...);
}
}
# 7 "./rpc.hh" 2
# 1 "./cxx_tuple.hh" 1
# 1 "./cxx_invoke.hh" 1
# 5 "./cxx_tuple.hh" 2
# 1 "./cxx_utils.hh" 1
# 1 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cassert" 1
# 42 "/Users/eschnett/SIMFACTORY/gcc-4.9.0/install/include/c++/4.9.0/cassert" 3
# 1 "/usr/include/assert.h" 1 3 4
# 42 "/usr/include/assert.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 484 "/usr/include/sys/cdefs.h" 3 4
# 1 "/usr/include/sys/_symbol_aliasing.h" 1 3 4
# 485 "/usr/include/sys/cdefs.h" 2 3 4
# 550 "/usr/include/sys/cdefs.h" 3 4
# 1 "/usr/include/sys/_posix_availability.h" 1 3 4
# 551 "/usr/include/sys/cdefs.h" 2 3 4
# 43 "/usr/include/assert.h" 2 3 4
# 1 "/usr/include/stdlib.h" 1 3 4
# 61 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/Availability.h" 1 3 4
# 148 "/usr/include/Availability.h" 3 4
# 1 "/usr/include/AvailabilityInternal.h" 1 3 4
# 149 "/usr/include/Availability.h" 2 3 4
# 62 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/_types.h" 1 3 4
# 27 "/usr/include/_types.h" 3 4
# 1 "/usr/include/sys/_types.h" 1 3 4
# 33 "/usr/include/sys/_types.h" 3 4
# 1 "/usr/include/machine/_types.h" 1 3 4
# 32 "/usr/include/machine/_types.h" 3 4
# 1 "/usr/include/i386/_types.h" 1 3 4
# 37 "/usr/include/i386/_types.h" 3 4
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef short __int16_t;
typedef unsigned short __uint16_t;
typedef int __int32_t;
typedef unsigned int __uint32_t;
typedef long long __int64_t;
typedef unsigned long long __uint64_t;
typedef long __darwin_intptr_t;
typedef unsigned int __darwin_natural_t;
# 70 "/usr/include/i386/_types.h" 3 4
typedef int __darwin_ct_rune_t;
typedef union {
char __mbstate8[128];
long long _mbstateL;
} __mbstate_t;
typedef __mbstate_t __darwin_mbstate_t;
typedef long int __darwin_ptrdiff_t;
typedef long unsigned int __darwin_size_t;
typedef __builtin_va_list __darwin_va_list;
typedef int __darwin_wchar_t;
typedef __darwin_wchar_t __darwin_rune_t;
typedef int __darwin_wint_t;
typedef unsigned long __darwin_clock_t;
typedef __uint32_t __darwin_socklen_t;
typedef long __darwin_ssize_t;
typedef long __darwin_time_t;
# 33 "/usr/include/machine/_types.h" 2 3 4
# 34 "/usr/include/sys/_types.h" 2 3 4
# 58 "/usr/include/sys/_types.h" 3 4
struct __darwin_pthread_handler_rec {
void (*__routine)(void *);
void *__arg;
struct __darwin_pthread_handler_rec *__next;
};
struct _opaque_pthread_attr_t {
long __sig;
char __opaque[56];
};
struct _opaque_pthread_cond_t {
long __sig;
char __opaque[40];
};
struct _opaque_pthread_condattr_t {
long __sig;
char __opaque[8];
};
struct _opaque_pthread_mutex_t {
long __sig;
char __opaque[56];
};
struct _opaque_pthread_mutexattr_t {
long __sig;
char __opaque[8];
};
struct _opaque_pthread_once_t {
long __sig;
char __opaque[8];
};
struct _opaque_pthread_rwlock_t {
long __sig;
char __opaque[192];
};
struct _opaque_pthread_rwlockattr_t {
long __sig;
char __opaque[16];
};
struct _opaque_pthread_t {
long __sig;
struct __darwin_pthread_handler_rec *__cleanup_stack;
char __opaque[1168];
};
# 94 "/usr/include/sys/_types.h" 3 4
typedef __int64_t __darwin_blkcnt_t;
typedef __int32_t __darwin_blksize_t;
typedef __int32_t __darwin_dev_t;
typedef unsigned int __darwin_fsblkcnt_t;
typedef unsigned int __darwin_fsfilcnt_t;
typedef __uint32_t __darwin_gid_t;
typedef __uint32_t __darwin_id_t;
typedef __uint64_t __darwin_ino64_t;
typedef __darwin_ino64_t __darwin_ino_t;
typedef __darwin_natural_t __darwin_mach_port_name_t;
typedef __darwin_mach_port_name_t __darwin_mach_port_t;
typedef __uint16_t __darwin_mode_t;
typedef __int64_t __darwin_off_t;
typedef __int32_t __darwin_pid_t;
typedef struct _opaque_pthread_attr_t __darwin_pthread_attr_t;
typedef struct _opaque_pthread_cond_t __darwin_pthread_cond_t;
typedef struct _opaque_pthread_condattr_t __darwin_pthread_condattr_t;
typedef unsigned long __darwin_pthread_key_t;
typedef struct _opaque_pthread_mutex_t __darwin_pthread_mutex_t;
typedef struct _opaque_pthread_mutexattr_t __darwin_pthread_mutexattr_t;
typedef struct _opaque_pthread_once_t __darwin_pthread_once_t;
typedef struct _opaque_pthread_rwlock_t __darwin_pthread_rwlock_t;
typedef struct _opaque_pthread_rwlockattr_t __darwin_pthread_rwlockattr_t;
typedef struct _opaque_pthread_t *__darwin_pthread_t;
typedef __uint32_t __darwin_sigset_t;
typedef __int32_t __darwin_suseconds_t;
typedef __uint32_t __darwin_uid_t;
typedef __uint32_t __darwin_useconds_t;
typedef unsigned char __darwin_uuid_t[16];
typedef char __darwin_uuid_string_t[37];
# 28 "/usr/include/_types.h" 2 3 4
# 39 "/usr/include/_types.h" 3 4
typedef int __darwin_nl_item;
typedef int __darwin_wctrans_t;
typedef __uint32_t __darwin_wctype_t;
# 64 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/sys/wait.h" 1 3 4
# 79 "/usr/include/sys/wait.h" 3 4
typedef enum {
P_ALL,
P_PID,
P_PGID
} idtype_t;
# 1 "/usr/include/sys/_types/_pid_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_pid_t.h" 3 4
typedef __darwin_pid_t pid_t;
# 90 "/usr/include/sys/wait.h" 2 3 4
# 1 "/usr/include/sys/_types/_id_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_id_t.h" 3 4
typedef __darwin_id_t id_t;
# 91 "/usr/include/sys/wait.h" 2 3 4
# 109 "/usr/include/sys/wait.h" 3 4
# 1 "/usr/include/sys/signal.h" 1 3 4
# 73 "/usr/include/sys/signal.h" 3 4
# 1 "/usr/include/sys/appleapiopts.h" 1 3 4
# 74 "/usr/include/sys/signal.h" 2 3 4
# 1 "/usr/include/machine/signal.h" 1 3 4
# 32 "/usr/include/machine/signal.h" 3 4
# 1 "/usr/include/i386/signal.h" 1 3 4
# 39 "/usr/include/i386/signal.h" 3 4
typedef int sig_atomic_t;
# 33 "/usr/include/machine/signal.h" 2 3 4
# 82 "/usr/include/sys/signal.h" 2 3 4
# 145 "/usr/include/sys/signal.h" 3 4
# 1 "/usr/include/machine/_mcontext.h" 1 3 4
# 29 "/usr/include/machine/_mcontext.h" 3 4
# 1 "/usr/include/i386/_mcontext.h" 1 3 4
# 33 "/usr/include/i386/_mcontext.h" 3 4
# 1 "/usr/include/mach/i386/_structs.h" 1 3 4
# 43 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_i386_thread_state {
unsigned int __eax;
unsigned int __ebx;
unsigned int __ecx;
unsigned int __edx;
unsigned int __edi;
unsigned int __esi;
unsigned int __ebp;
unsigned int __esp;
unsigned int __ss;
unsigned int __eflags;
unsigned int __eip;
unsigned int __cs;
unsigned int __ds;
unsigned int __es;
unsigned int __fs;
unsigned int __gs;
};
# 89 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_fp_control {
unsigned short __invalid : 1, __denorm : 1, __zdiv : 1, __ovrfl : 1,
__undfl : 1, __precis : 1, : 2, __pc : 2, __rc : 2, : 1, : 3;
};
typedef struct __darwin_fp_control __darwin_fp_control_t;
# 147 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_fp_status {
unsigned short __invalid : 1, __denorm : 1, __zdiv : 1, __ovrfl : 1,
__undfl : 1, __precis : 1, __stkflt : 1, __errsumm : 1, __c0 : 1,
__c1 : 1, __c2 : 1, __tos : 3, __c3 : 1, __busy : 1;
};
typedef struct __darwin_fp_status __darwin_fp_status_t;
# 191 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_mmst_reg {
char __mmst_reg[10];
char __mmst_rsrv[6];
};
# 210 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_xmm_reg {
char __xmm_reg[16];
};
# 232 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_i386_float_state {
int __fpu_reserved[2];
struct __darwin_fp_control __fpu_fcw;
struct __darwin_fp_status __fpu_fsw;
__uint8_t __fpu_ftw;
__uint8_t __fpu_rsrv1;
__uint16_t __fpu_fop;
__uint32_t __fpu_ip;
__uint16_t __fpu_cs;
__uint16_t __fpu_rsrv2;
__uint32_t __fpu_dp;
__uint16_t __fpu_ds;
__uint16_t __fpu_rsrv3;
__uint32_t __fpu_mxcsr;
__uint32_t __fpu_mxcsrmask;
struct __darwin_mmst_reg __fpu_stmm0;
struct __darwin_mmst_reg __fpu_stmm1;
struct __darwin_mmst_reg __fpu_stmm2;
struct __darwin_mmst_reg __fpu_stmm3;
struct __darwin_mmst_reg __fpu_stmm4;
struct __darwin_mmst_reg __fpu_stmm5;
struct __darwin_mmst_reg __fpu_stmm6;
struct __darwin_mmst_reg __fpu_stmm7;
struct __darwin_xmm_reg __fpu_xmm0;
struct __darwin_xmm_reg __fpu_xmm1;
struct __darwin_xmm_reg __fpu_xmm2;
struct __darwin_xmm_reg __fpu_xmm3;
struct __darwin_xmm_reg __fpu_xmm4;
struct __darwin_xmm_reg __fpu_xmm5;
struct __darwin_xmm_reg __fpu_xmm6;
struct __darwin_xmm_reg __fpu_xmm7;
char __fpu_rsrv4[14 * 16];
int __fpu_reserved1;
};
struct __darwin_i386_avx_state {
int __fpu_reserved[2];
struct __darwin_fp_control __fpu_fcw;
struct __darwin_fp_status __fpu_fsw;
__uint8_t __fpu_ftw;
__uint8_t __fpu_rsrv1;
__uint16_t __fpu_fop;
__uint32_t __fpu_ip;
__uint16_t __fpu_cs;
__uint16_t __fpu_rsrv2;
__uint32_t __fpu_dp;
__uint16_t __fpu_ds;
__uint16_t __fpu_rsrv3;
__uint32_t __fpu_mxcsr;
__uint32_t __fpu_mxcsrmask;
struct __darwin_mmst_reg __fpu_stmm0;
struct __darwin_mmst_reg __fpu_stmm1;
struct __darwin_mmst_reg __fpu_stmm2;
struct __darwin_mmst_reg __fpu_stmm3;
struct __darwin_mmst_reg __fpu_stmm4;
struct __darwin_mmst_reg __fpu_stmm5;
struct __darwin_mmst_reg __fpu_stmm6;
struct __darwin_mmst_reg __fpu_stmm7;
struct __darwin_xmm_reg __fpu_xmm0;
struct __darwin_xmm_reg __fpu_xmm1;
struct __darwin_xmm_reg __fpu_xmm2;
struct __darwin_xmm_reg __fpu_xmm3;
struct __darwin_xmm_reg __fpu_xmm4;
struct __darwin_xmm_reg __fpu_xmm5;
struct __darwin_xmm_reg __fpu_xmm6;
struct __darwin_xmm_reg __fpu_xmm7;
char __fpu_rsrv4[14 * 16];
int __fpu_reserved1;
char __avx_reserved1[64];
struct __darwin_xmm_reg __fpu_ymmh0;
struct __darwin_xmm_reg __fpu_ymmh1;
struct __darwin_xmm_reg __fpu_ymmh2;
struct __darwin_xmm_reg __fpu_ymmh3;
struct __darwin_xmm_reg __fpu_ymmh4;
struct __darwin_xmm_reg __fpu_ymmh5;
struct __darwin_xmm_reg __fpu_ymmh6;
struct __darwin_xmm_reg __fpu_ymmh7;
};
# 402 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_i386_exception_state {
__uint16_t __trapno;
__uint16_t __cpu;
__uint32_t __err;
__uint32_t __faultvaddr;
};
# 422 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_debug_state32 {
unsigned int __dr0;
unsigned int __dr1;
unsigned int __dr2;
unsigned int __dr3;
unsigned int __dr4;
unsigned int __dr5;
unsigned int __dr6;
unsigned int __dr7;
};
# 454 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_thread_state64 {
__uint64_t __rax;
__uint64_t __rbx;
__uint64_t __rcx;
__uint64_t __rdx;
__uint64_t __rdi;
__uint64_t __rsi;
__uint64_t __rbp;
__uint64_t __rsp;
__uint64_t __r8;
__uint64_t __r9;
__uint64_t __r10;
__uint64_t __r11;
__uint64_t __r12;
__uint64_t __r13;
__uint64_t __r14;
__uint64_t __r15;
__uint64_t __rip;
__uint64_t __rflags;
__uint64_t __cs;
__uint64_t __fs;
__uint64_t __gs;
};
# 509 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_float_state64 {
int __fpu_reserved[2];
struct __darwin_fp_control __fpu_fcw;
struct __darwin_fp_status __fpu_fsw;
__uint8_t __fpu_ftw;
__uint8_t __fpu_rsrv1;
__uint16_t __fpu_fop;
__uint32_t __fpu_ip;
__uint16_t __fpu_cs;
__uint16_t __fpu_rsrv2;
__uint32_t __fpu_dp;
__uint16_t __fpu_ds;
__uint16_t __fpu_rsrv3;
__uint32_t __fpu_mxcsr;
__uint32_t __fpu_mxcsrmask;
struct __darwin_mmst_reg __fpu_stmm0;
struct __darwin_mmst_reg __fpu_stmm1;
struct __darwin_mmst_reg __fpu_stmm2;
struct __darwin_mmst_reg __fpu_stmm3;
struct __darwin_mmst_reg __fpu_stmm4;
struct __darwin_mmst_reg __fpu_stmm5;
struct __darwin_mmst_reg __fpu_stmm6;
struct __darwin_mmst_reg __fpu_stmm7;
struct __darwin_xmm_reg __fpu_xmm0;
struct __darwin_xmm_reg __fpu_xmm1;
struct __darwin_xmm_reg __fpu_xmm2;
struct __darwin_xmm_reg __fpu_xmm3;
struct __darwin_xmm_reg __fpu_xmm4;
struct __darwin_xmm_reg __fpu_xmm5;
struct __darwin_xmm_reg __fpu_xmm6;
struct __darwin_xmm_reg __fpu_xmm7;
struct __darwin_xmm_reg __fpu_xmm8;
struct __darwin_xmm_reg __fpu_xmm9;
struct __darwin_xmm_reg __fpu_xmm10;
struct __darwin_xmm_reg __fpu_xmm11;
struct __darwin_xmm_reg __fpu_xmm12;
struct __darwin_xmm_reg __fpu_xmm13;
struct __darwin_xmm_reg __fpu_xmm14;
struct __darwin_xmm_reg __fpu_xmm15;
char __fpu_rsrv4[6 * 16];
int __fpu_reserved1;
};
struct __darwin_x86_avx_state64 {
int __fpu_reserved[2];
struct __darwin_fp_control __fpu_fcw;
struct __darwin_fp_status __fpu_fsw;
__uint8_t __fpu_ftw;
__uint8_t __fpu_rsrv1;
__uint16_t __fpu_fop;
__uint32_t __fpu_ip;
__uint16_t __fpu_cs;
__uint16_t __fpu_rsrv2;
__uint32_t __fpu_dp;
__uint16_t __fpu_ds;
__uint16_t __fpu_rsrv3;
__uint32_t __fpu_mxcsr;
__uint32_t __fpu_mxcsrmask;
struct __darwin_mmst_reg __fpu_stmm0;
struct __darwin_mmst_reg __fpu_stmm1;
struct __darwin_mmst_reg __fpu_stmm2;
struct __darwin_mmst_reg __fpu_stmm3;
struct __darwin_mmst_reg __fpu_stmm4;
struct __darwin_mmst_reg __fpu_stmm5;
struct __darwin_mmst_reg __fpu_stmm6;
struct __darwin_mmst_reg __fpu_stmm7;
struct __darwin_xmm_reg __fpu_xmm0;
struct __darwin_xmm_reg __fpu_xmm1;
struct __darwin_xmm_reg __fpu_xmm2;
struct __darwin_xmm_reg __fpu_xmm3;
struct __darwin_xmm_reg __fpu_xmm4;
struct __darwin_xmm_reg __fpu_xmm5;
struct __darwin_xmm_reg __fpu_xmm6;
struct __darwin_xmm_reg __fpu_xmm7;
struct __darwin_xmm_reg __fpu_xmm8;
struct __darwin_xmm_reg __fpu_xmm9;
struct __darwin_xmm_reg __fpu_xmm10;
struct __darwin_xmm_reg __fpu_xmm11;
struct __darwin_xmm_reg __fpu_xmm12;
struct __darwin_xmm_reg __fpu_xmm13;
struct __darwin_xmm_reg __fpu_xmm14;
struct __darwin_xmm_reg __fpu_xmm15;
char __fpu_rsrv4[6 * 16];
int __fpu_reserved1;
char __avx_reserved1[64];
struct __darwin_xmm_reg __fpu_ymmh0;
struct __darwin_xmm_reg __fpu_ymmh1;
struct __darwin_xmm_reg __fpu_ymmh2;
struct __darwin_xmm_reg __fpu_ymmh3;
struct __darwin_xmm_reg __fpu_ymmh4;
struct __darwin_xmm_reg __fpu_ymmh5;
struct __darwin_xmm_reg __fpu_ymmh6;
struct __darwin_xmm_reg __fpu_ymmh7;
struct __darwin_xmm_reg __fpu_ymmh8;
struct __darwin_xmm_reg __fpu_ymmh9;
struct __darwin_xmm_reg __fpu_ymmh10;
struct __darwin_xmm_reg __fpu_ymmh11;
struct __darwin_xmm_reg __fpu_ymmh12;
struct __darwin_xmm_reg __fpu_ymmh13;
struct __darwin_xmm_reg __fpu_ymmh14;
struct __darwin_xmm_reg __fpu_ymmh15;
};
# 751 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_exception_state64 {
__uint16_t __trapno;
__uint16_t __cpu;
__uint32_t __err;
__uint64_t __faultvaddr;
};
# 771 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_debug_state64 {
__uint64_t __dr0;
__uint64_t __dr1;
__uint64_t __dr2;
__uint64_t __dr3;
__uint64_t __dr4;
__uint64_t __dr5;
__uint64_t __dr6;
__uint64_t __dr7;
};
# 34 "/usr/include/i386/_mcontext.h" 2 3 4
struct __darwin_mcontext32 {
struct __darwin_i386_exception_state __es;
struct __darwin_i386_thread_state __ss;
struct __darwin_i386_float_state __fs;
};
struct __darwin_mcontext_avx32 {
struct __darwin_i386_exception_state __es;
struct __darwin_i386_thread_state __ss;
struct __darwin_i386_avx_state __fs;
};
# 76 "/usr/include/i386/_mcontext.h" 3 4
struct __darwin_mcontext64 {
struct __darwin_x86_exception_state64 __es;
struct __darwin_x86_thread_state64 __ss;
struct __darwin_x86_float_state64 __fs;
};
struct __darwin_mcontext_avx64 {
struct __darwin_x86_exception_state64 __es;
struct __darwin_x86_thread_state64 __ss;
struct __darwin_x86_avx_state64 __fs;
};
# 115 "/usr/include/i386/_mcontext.h" 3 4
typedef struct __darwin_mcontext64 *mcontext_t;
# 30 "/usr/include/machine/_mcontext.h" 2 3 4
# 146 "/usr/include/sys/signal.h" 2 3 4
# 1 "/usr/include/sys/_types/_sigaltstack.h" 1 3 4
# 36 "/usr/include/sys/_types/_sigaltstack.h" 3 4
struct __darwin_sigaltstack {
void *ss_sp;
__darwin_size_t ss_size;
int ss_flags;
};
typedef struct __darwin_sigaltstack stack_t;
# 147 "/usr/include/sys/signal.h" 2 3 4
# 1 "/usr/include/sys/_types/_ucontext.h" 1 3 4
# 34 "/usr/include/sys/_types/_ucontext.h" 3 4
struct __darwin_ucontext {
int uc_onstack;
__darwin_sigset_t uc_sigmask;
struct __darwin_sigaltstack uc_stack;
struct __darwin_ucontext *uc_link;
__darwin_size_t uc_mcsize;
struct __darwin_mcontext64 *uc_mcontext;
};
typedef struct __darwin_ucontext ucontext_t;
# 148 "/usr/include/sys/signal.h" 2 3 4
# 1 "/usr/include/sys/_types/_pthread_attr_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_pthread_attr_t.h" 3 4
typedef __darwin_pthread_attr_t pthread_attr_t;
# 151 "/usr/include/sys/signal.h" 2 3 4
# 1 "/usr/include/sys/_types/_sigset_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_sigset_t.h" 3 4
typedef __darwin_sigset_t sigset_t;
# 152 "/usr/include/sys/signal.h" 2 3 4
# 1 "/usr/include/sys/_types/_size_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_size_t.h" 3 4
typedef __darwin_size_t size_t;
# 153 "/usr/include/sys/signal.h" 2 3 4
# 1 "/usr/include/sys/_types/_uid_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_uid_t.h" 3 4
typedef __darwin_uid_t uid_t;
# 154 "/usr/include/sys/signal.h" 2 3 4
union sigval {
int sival_int;
void *sival_ptr;
};
struct sigevent {
int sigev_notify;
int sigev_signo;
union sigval sigev_value;
void (*sigev_notify_function)(union sigval);
pthread_attr_t *sigev_notify_attributes;
};
typedef struct __siginfo {
int si_signo;
int si_errno;
int si_code;
pid_t si_pid;
uid_t si_uid;
int si_status;
void *si_addr;
union sigval si_value;
long si_band;
unsigned long __pad[7];
} siginfo_t;
# 266 "/usr/include/sys/signal.h" 3 4
union __sigaction_u {
void (*__sa_handler)(int);
void (*__sa_sigaction)(int, struct __siginfo *, void *);
};
struct __sigaction {
union __sigaction_u __sigaction_u;
void (*sa_tramp)(void *, int, int, siginfo_t *, void *);
sigset_t sa_mask;
int sa_flags;
};
struct sigaction {
union __sigaction_u __sigaction_u;
sigset_t sa_mask;
int sa_flags;
};
# 328 "/usr/include/sys/signal.h" 3 4
typedef void (*sig_t)(int);
# 345 "/usr/include/sys/signal.h" 3 4
struct sigvec {
void (*sv_handler)(int);
int sv_mask;
int sv_flags;
};
# 364 "/usr/include/sys/signal.h" 3 4
struct sigstack {
char *ss_sp;
int ss_onstack;
};
# 386 "/usr/include/sys/signal.h" 3 4
extern "C" { void (*signal(int, void (*)(int)))(int); }
# 110 "/usr/include/sys/wait.h" 2 3 4
# 1 "/usr/include/sys/resource.h" 1 3 4
# 72 "/usr/include/sys/resource.h" 3 4
# 1 "/Users/eschnett/SIMFACTORY/llvm-3.4.2/install/bin/../lib/clang/3.4.2/include/stdint.h" 1 3 4
# 64 "/Users/eschnett/SIMFACTORY/llvm-3.4.2/install/bin/../lib/clang/3.4.2/include/stdint.h" 3 4
# 1 "/usr/include/stdint.h" 1 3 4
# 18 "/usr/include/stdint.h" 3 4
# 1 "/usr/include/sys/_types/_int8_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_int8_t.h" 3 4
typedef signed char int8_t;
# 19 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/sys/_types/_int16_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_int16_t.h" 3 4
typedef short int16_t;
# 20 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/sys/_types/_int32_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_int32_t.h" 3 4
typedef int int32_t;
# 21 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/sys/_types/_int64_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_int64_t.h" 3 4
typedef long long int64_t;
# 22 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/_types/_uint8_t.h" 1 3 4
# 31 "/usr/include/_types/_uint8_t.h" 3 4
typedef unsigned char uint8_t;
# 24 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/_types/_uint16_t.h" 1 3 4
# 31 "/usr/include/_types/_uint16_t.h" 3 4
typedef unsigned short uint16_t;
# 25 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/_types/_uint32_t.h" 1 3 4