namespace llvm {
    class FunctionPass;
    class Pass;
    Pass *createLoopUnswitchPass(bool OptimizeForSize = false);
    }
    extern "C" {
    typedef __w64 unsigned int uintptr_t;
    typedef char *va_list;
    }
    extern "C" {
    typedef __w64 unsigned int size_t;
    typedef size_t rsize_t;
    typedef __w64 int intptr_t;
    typedef __w64 int ptrdiff_t;
    typedef unsigned short wint_t;
    typedef int errno_t;
    typedef __w64 long __time32_t;
    typedef __int64 __time64_t;
    typedef __time64_t time_t;
    void __cdecl _invalid_parameter(const wchar_t *, const wchar_t *,                                 const wchar_t *, unsigned int, uintptr_t);
    typedef struct localeinfo_struct {
 }
    _locale_tstruct, *_locale_t;
    typedef struct localerefcount {
 }
    threadlocinfo;
    }
    namespace std {
    typedef bool _Bool;
    }
    namespace std {
    enum _Uninitialized {
   _Noinit };
    class _Lockit {
  public:   __thiscall _Lockit();
 };
    class _Init_locks {
   static void __cdecl _Init_locks_dtor(_Init_locks *);
 };
    }
    typedef int _Mbstatet;
    namespace std {
    using ::ptrdiff_t;
    using ::size_t;
    typedef double max_align_t;
    }
    extern "C" {
    typedef struct _div_t {
   int quot;
 }
    div_t;
    typedef struct _ldiv_t {
 }
    ldiv_t;
    typedef struct _lldiv_t {
 }
    lldiv_t;
    typedef struct {
   long double x;
 }
    _LONGDOUBLE;
    typedef struct {
   unsigned char ld12[12];
 }
    _LDBL12;
    extern int __mb_cur_max;
    errno_t __cdecl _itoa_s(int _Value, char *_DstBuf, size_t _Size, int _Radix);
    extern "C++" {
 }
    char *__cdecl _itoa(int _Value, char *_Dest, int _Radix);
    lldiv_t __cdecl lldiv(long long _Numerator, long long _Denominator);
    extern "C++" {
 }
    errno_t __cdecl _ltoa_s(long _Val, char *_DstBuf, size_t _Size, int _Radix);
    int __cdecl system(const char *_Command);
    errno_t __cdecl _ultoa_s(unsigned long _Val, char *_DstBuf, size_t _Size,                          int _Radix);
    extern "C++" {
 }
    char *__cdecl _ultoa(unsigned long _Value, char *_Dest, int _Radix);
    using ::system;
    }
    extern "C" {
    typedef union {
   unsigned short _Word[8];
 }
    _Dconst;
    void __cdecl _Feraise(int);
    extern _Dconst _LDenorm, _LInf, _LNan, _LSnan;
    }
    namespace std {
    struct _Nil {
};
    static _Nil _Nil_obj;
    template <class _Ty, _Ty _Val> struct integral_constant {
   static const _Ty value = _Val;
   typedef _Ty value_type;
   operator value_type() const { return (value); }
 };
    typedef integral_constant<bool, true> true_type;
    typedef integral_constant<bool, false> false_type;
    template <bool> struct _Cat_base : false_type {
};
    template <> struct _Cat_base<true> : true_type {
};
    template <bool _Test, class _Ty = void> struct enable_if {
   typedef _Ty type;
 };
    template <bool _Test, class _Ty1, class _Ty2> struct conditional {
   typedef _Ty2 type;
 };
    template <class _Ty1, class _Ty2> struct is_same : false_type {
};
    template <class _Ty1> struct is_same<_Ty1, _Ty1> : true_type {
};
    template <class _Ty> struct remove_const {
   typedef _Ty type;
 };
    template <class _Ty> struct remove_volatile {
   typedef _Ty type;
 };
    template <class _Ty> struct remove_cv {
   typedef typename remove_const<typename remove_volatile<_Ty>::type>::type type;
 };
    template <class _Ty> struct _Is_integral : false_type {
};
    template <> struct _Is_integral<signed short> : true_type {
};
    template <> struct _Is_integral<unsigned __int64> : true_type {
};
    template <class _Ty> struct is_integral : _Is_integral<typename remove_cv<_Ty>::type> {
};
    template <class _Ty> struct _Is_floating_point : false_type {
};
    template <> struct _Is_floating_point<float> : true_type {
};
    template <class _Ty> struct is_floating_point : _Is_floating_point<typename remove_cv<_Ty>::type> {
};
    template <class _Ty> struct _Is_numeric     : _Cat_base<is_integral<_Ty>::value || is_floating_point<_Ty>::value> {
};
    template <class _Ty> struct remove_reference {
   typedef _Ty type;
 };
    template <class _Ty> struct remove_reference<_Ty &> {
   typedef _Ty type;
 };
    template <class _Tgt, class _Src> struct _Copy_cv {
   typedef typename remove_reference<_Tgt>::type _Tgtx;
   typedef _Tgtx &type;
   typedef const volatile _Tgtx &type;
 };
    struct _Wrap_int {
   _Wrap_int(int) {}
 };
    template <class _Ty> struct _Has_result_type {
 };
    }
    extern "C" {
    struct _iobuf {
   char *_ptr;
 };
    typedef struct _iobuf FILE;
    typedef unsigned long _fsize_t;
    struct _wfinddata32_t {
   wchar_t name[260];
 };
    struct _stat32 {
 };
    extern "C++" {
 template <size_t _Size> inline errno_t __cdecl _wstrtime_s(wchar_t (&_Buffer)[_Size]) throw() {   return _wstrtime_s(_Buffer, _Size); }
 }
    wchar_t *__cdecl _wstrtime(wchar_t *_Buffer);
    wchar_t *__cdecl _wctime64(const __time64_t *_Time);
    extern "C++" {
 template <size_t _Size> inline errno_t __cdecl _wctime64_s(wchar_t (&_Buffer)[_Size],                                    const __time64_t *_Time) throw() {   return _wctime64_s(_Buffer, _Size, _Time); }
 }
    static __inline wchar_t *__cdecl _wctime(const time_t *_Time) {
   return _wctime64(_Time);
 }
    void *__cdecl memcpy(void *_Dst, const void *_Src, size_t _Size);
    __inline int __cdecl fwide(FILE *_F, int _M) {
 }
    __inline const wchar_t *__cdecl wmemchr(const wchar_t *_S, wchar_t _C,                                         size_t _N) {
   for (;
 0 < _N;
 ++_S, --_N)     if (*_S == _C) return (const wchar_t *)(_S);
   return (0);
 }
    __inline int __cdecl wmemcmp(const wchar_t *_S1, const wchar_t *_S2,                              size_t _N) {
   for (;
 0 < _N;
 ++_S1, ++_S2, --_N)     if (*_S1 != *_S2) return (*_S1 < *_S2 ? -1 : +1);
   return (0);
 }
    __inline wchar_t *__cdecl wmemcpy(wchar_t *_S1, const wchar_t *_S2, size_t _N) {
   return (wchar_t *)memcpy(_S1, _S2, _N * sizeof(wchar_t));
 }
    }
    namespace std {
    template <class _Ty> inline _Ty *addressof(_Ty &_Val) throw() {
 }
    template <bool, class _Ty1, class _Ty2> struct _If {
   typedef _Ty1 type;
 };
    template <class _Arg, class _Result> struct unary_function {
   typedef _Result result_type;
 };
    template <class _Arg1, class _Arg2, class _Result> struct binary_function {
 };
    template <class _Ty> struct less : public binary_function<_Ty, _Ty, bool> {
   bool operator()(const _Ty &_Left, const _Ty &_Right) const {     return (_Left < _Right);   }
 };
    inline size_t _Hash_seq(const unsigned char *_First, size_t _Count) {
   static_assert(sizeof(size_t) == 4, "This code is for 32-bit size_t.");
   const size_t _FNV_offset_basis = 2166136261U;
   const size_t _FNV_prime = 16777619U;
   size_t _Val = _FNV_offset_basis;
   for (size_t _Next = 0;
 _Next < _Count;
 ++_Next) {     _Val ^= (size_t)_First[_Next];     _Val *= _FNV_prime;   }
   static_assert(sizeof(size_t) == 4, "This code is for 32-bit size_t.");
 }
    template <class _Kty> struct _Bitwise_hash : public unary_function<_Kty, size_t> {
 };
    template <class _Kty> struct hash : public _Bitwise_hash<_Kty> {
   static const bool _Value = __is_enum(_Kty);
   static_assert(_Value,                 "The C++ Standard doesn't provide a hash for this type.");
 };
    template <> struct hash<bool> : public _Bitwise_hash<bool> {
};
    template <> struct hash<short> : public _Bitwise_hash<short> {
};
    }
    namespace std {
    template <class = _Nil, class _V0_t = _Nil, class _V1_t = _Nil,           class _V2_t = _Nil, class _V3_t = _Nil, class _V4_t = _Nil,           class _V5_t = _Nil, class _V6_t = _Nil, class _V7_t = _Nil,           class _V8_t = _Nil, class _V9_t = _Nil, class _V10_t = _Nil,           class = _Nil> struct _Sizeof;
    template <> struct _Sizeof<_Nil, _Nil, _Nil, _Nil, _Nil, _Nil, _Nil, _Nil, _Nil, _Nil, _Nil,                _Nil, _Nil> {
 };
    typedef enum {
   denorm_indeterminate = -1,   denorm_absent = 0,   denorm_present = 1 }
    float_denorm_style;
    typedef enum {
   round_indeterminate = -1,   round_toward_zero = 0,   round_to_nearest = 1,   round_toward_infinity = 2,   round_toward_neg_infinity = 3 }
    float_round_style;
    struct _Num_base {
   static const bool is_integer = (bool)(false);
   static const bool is_modulo = (bool)(false);
   static const bool is_signed = (bool)(false);
   static const int digits = (int)(0);
   static const int digits10 = (int)(0);
   static const int radix = (int)(0);
 };
    template <class _Ty> class numeric_limits : public _Num_base {
};
    template <class _Ty> class numeric_limits<const volatile _Ty> : public numeric_limits<_Ty> {
};
    struct _Num_int_base : public _Num_base {
 };
    template <> class numeric_limits<unsigned __int64> : public _Num_int_base {
  public:   typedef unsigned __int64 _Ty;
   static const int min_exponent10 = (int)((int)(-307));
 };
    }
    inline void *__cdecl operator new(size_t, void *_Where) {
    return (_Where);
    }
    extern "C" {
    FILE *__cdecl __iob_func(void);
    void *__cdecl _memccpy(void *_Dst, const void *_Src, int _Val,                        size_t _MaxCount);
    const void *__cdecl memchr(const void *_Buf, int _Val, size_t _MaxCount);
    int __cdecl memcmp(const void *_Buf1, const void *_Buf2, size_t _Size);
    void *__cdecl memcpy(void *_Dst, const void *_Src, size_t _Size);
    void *__cdecl memset(void *_Dst, int _Val, size_t _Size);
    void *__cdecl memccpy(void *_Dst, const void *_Src, int _Val, size_t _Size);
    errno_t __cdecl _strset_s(char *_Dst, size_t _DstSize, int _Value);
    extern "C++" {
 }
    int __cdecl strcmp(const char *_Str1, const char *_Str2);
    size_t __cdecl strlen(const char *_Str);
    void *__cdecl memmove(void *_Dst, const void *_Src, size_t _Size);
    char *__cdecl _strdup(const char *_Src);
    errno_t __cdecl _strnset_s(char *_Str, size_t _SizeInBytes, int _Val,                            size_t _MaxCount);
    extern "C++" {
 template <size_t _Size> inline errno_t __cdecl _strnset_s(char (&_Dest)[_Size], int _Val,                                   size_t _Count) throw() {   return _strnset_s(_Dest, _Size, _Val, _Count); }
 }
    size_t __cdecl strxfrm(char *_Dst, const char *_Src, size_t _MaxCount);
    size_t __cdecl _strxfrm_l(char *_Dst, const char *_Src, size_t _MaxCount,                           _locale_t _Locale);
    extern "C++" {
 }
    using ::strxfrm;
    }
    namespace std {
    template <class _Statetype> class fpos {
   typedef fpos<_Statetype> _Myt;
 };
    typedef fpos<_Mbstatet> streampos;
    template <class _Elem, class _Int_type> struct _Char_traits {
   typedef _Elem char_type;
 };
    template <class _Elem> struct char_traits : public _Char_traits<_Elem, long> {
};
    template <> struct char_traits<wchar_t> {
 };
    template <> struct char_traits<char> {
   typedef char _Elem;
   static size_t __cdecl length(const _Elem *_First) {     return (*_First == 0 ? 0 : ::strlen(_First));   }
   static _Elem *__cdecl copy(_Elem *_First1, const _Elem *_First2,                              size_t _Count) {     return (_Count == 0 ? _First1                         : (_Elem *)::memcpy(_First1, _First2, _Count));   }
   static const _Elem *__cdecl find(const _Elem *_First, size_t _Count,                                    const _Elem &_Ch) {     return (_Count == 0 ? (const _Elem *)0                         : (const _Elem *)::memchr(_First, _Ch, _Count));   }
   static _Elem *__cdecl move(_Elem *_First1, const _Elem *_First2,                              size_t _Count) {     return (_Count == 0 ? _First1                         : (_Elem *)::memmove(_First1, _First2, _Count));   }
   static void __cdecl assign(_Elem &_Left, const _Elem &_Right) throw() {     _Left = _Right;   }
   static bool __cdecl eq(const _Elem &_Left, const _Elem &_Right) throw() {     return (_Left == _Right);   }
 };
    template <class _Ty> struct _Ptr_traits {
   static const bool _Is_volatile = false;
 };
    template <class _Ty> struct _Ptr_traits<const _Ty *> {
 };
    template <class _Ty> struct _Ptr_traits<const volatile _Ty *> {
   static const bool _Is_const = true;
 };
    template <class _Ty> struct _Is_funptr : false_type {
};
    template <class _Ty> struct _Is_memfunptr : false_type {
};
    template <class _Ret> struct _Is_funptr<_Ret (*)()> : true_type {
};
    template <class _Ret, class _Arg0, class _V0_t, class _V1_t, class _V2_t,           class _V3_t, class _V4_t, class _V5_t, class _V6_t, class _V7_t,           class _V8_t, class _V9_t> struct _Is_memfunptr<_Ret (_Arg0::*)(_V0_t, _V1_t, _V2_t, _V3_t, _V4_t, _V5_t,                                      _V6_t, _V7_t, _V8_t,                                      _V9_t...) volatile> : true_type {
};
    template <class _Ty> struct add_const {
   typedef const _Ty type;
 };
    template <class _Ty> struct add_volatile {
   typedef volatile _Ty type;
   typedef typename add_const<typename add_volatile<_Ty>::type>::type type;
 };
    template <class _Ty> struct add_reference {
   typedef typename remove_reference<_Ty>::type &type;
 };
    template <class _Ty> struct add_lvalue_reference {
   typedef typename add_reference<_Ty>::type type;
 };
    template <class _Ty> struct add_rvalue_reference {
   typedef typename remove_reference<_Ty>::type &&type;
 };
    template <class _Ty> struct add_rvalue_reference<_Ty &> {
   typedef _Ty &type;
 };
    template <class _Ty> typename add_rvalue_reference<_Ty>::type declval(int = 0) throw();
    template <class _Ty> struct remove_extent {
   typedef _Ty type;
 };
    template <class _Ty> struct remove_all_extents {
   typedef _Ty type;
 };
    template <class _Ty> struct _Is_void : false_type {
};
    template <class _Ty> struct is_void : _Is_void<typename remove_cv<_Ty>::type> {
};
    template <class _Ty> struct is_array : false_type {
};
    template <class _Ty> struct is_array<_Ty[]> : true_type {
};
    template <class _Ty> struct is_lvalue_reference : false_type {
};
    template <class _Ty> struct is_rvalue_reference : false_type {
};
    template <class _Ty> struct is_reference : _Cat_base<is_lvalue_reference<_Ty>::value ||                                 is_rvalue_reference<_Ty>::value> {
};
    template <class _Ty> struct _Is_member_object_pointer : false_type {
};
    template <class _Ty> struct is_member_object_pointer     : _Is_member_object_pointer<typename remove_cv<_Ty>::type> {
};
    template <class _Ty> struct is_member_function_pointer     : _Cat_base<_Is_memfunptr<typename remove_cv<_Ty>::type>::value> {
};
    template <class _Ty> struct _Is_pointer : false_type {
};
    template <class _Ty> struct _Is_pointer<_Ty *> : _Cat_base<     !is_member_object_pointer<_Ty *>::value &&     !is_member_function_pointer<_Ty *>::value> {
};
    template <class _Ty> struct is_pointer : _Is_pointer<typename remove_cv<_Ty>::type> {
};
    template <class _Ty> struct is_class : _Cat_base<__is_class(_Ty)> {
};
    template <class _Ty> struct is_function     : _Cat_base<_Is_funptr<typename remove_cv<_Ty>::type *>::value> {
};
    template <class _Ty> struct is_function<_Ty &&> : false_type {
};
    template <class _Ty> struct is_arithmetic     : _Cat_base<is_integral<_Ty>::value || is_floating_point<_Ty>::value> {
};
    template <class _Ty> struct is_object     : _Cat_base<!is_function<_Ty>::value && !is_reference<_Ty>::value &&                 !is_void<_Ty>::value> {
};
    template <class _From, class _To> struct is_convertible : _Cat_base<is_void<_From>::value &&is_void<_To>::value ||                                   __is_convertible_to(_From, _To)> {
};
    template <class _Ty> struct is_enum : _Cat_base<__is_enum(_Ty)> {
};
    template <class _Ty> struct is_member_pointer : _Cat_base<is_member_object_pointer<_Ty>::value ||                                      is_member_function_pointer<_Ty>::value> {
};
    template <class _Ty> struct is_scalar     : _Cat_base<is_arithmetic<_Ty>::value || is_enum<_Ty>::value ||                 is_pointer<_Ty>::value || is_member_pointer<_Ty>::value> {
};
    template <class _Ty> struct is_const     : _Cat_base<_Ptr_traits<_Ty *>::_Is_const && !is_function<_Ty>::value> {
};
    template <class _Ty, unsigned int _Nx> struct is_const<_Ty[_Nx]> : false_type {
};
    template <class _Ty> struct is_volatile     : _Cat_base<_Ptr_traits<_Ty *>::_Is_volatile && !is_function<_Ty>::value> {
 };
    template <class _Ty> struct is_volatile<_Ty &> : false_type {
};
    template <class _Ty> struct _Is_pod : _Cat_base<is_void<_Ty>::value || is_scalar<_Ty>::value ||                            __has_trivial_constructor(_Ty) && __is_pod(_Ty)> {
};
    template <class _Ty> struct is_pod : _Is_pod<typename remove_all_extents<_Ty>::type> {
};
    template <class _Ty> struct is_empty : _Cat_base<__is_empty(_Ty)> {
};
    template <class _Ty> struct is_trivial : _Cat_base<__is_trivial(_Ty)> {
};
    template <class, class _V0_t = _Nil, class _V1_t = _Nil, class _V2_t = _Nil,           class _V3_t = _Nil, class _V4_t = _Nil, class _V5_t = _Nil,           class _V6_t = _Nil, class _V7_t = _Nil, class _V8_t = _Nil,           class _V9_t = _Nil, class _V10_t = _Nil, class = _Nil> struct is_constructible;
    template <bool, class, class _V0_t = _Nil, class _V1_t = _Nil,           class _V2_t = _Nil, class _V3_t = _Nil, class _V4_t = _Nil,           class _V5_t = _Nil, class _V6_t = _Nil, class _V7_t = _Nil,           class _V8_t = _Nil, class _V9_t = _Nil, class _V10_t = _Nil,           class = _Nil> struct _Is_constructible;
    template <class _Ty, class _V0_t, class _V1_t, class _V2_t, class _V3_t,           class _V4_t> struct is_constructible<     _Ty, _V0_t, _V1_t, _V2_t, _V3_t, _V4_t, _Nil, _Nil, _Nil, _Nil, _Nil,     _Nil> : _If<is_void<_Ty>::value, true_type,                 typename _Is_constructible<                     is_object<_Ty>::value &&(!is_scalar<_Ty>::value ||                                              _Sizeof<int, _V0_t, _V1_t, _V2_t,                                                      _V3_t, _V4_t>::value <= 2),                     typename remove_all_extents<_Ty>::type, _V0_t, _V1_t, _V2_t,                     _V3_t, _V4_t>::type>::type {
};
    template <class _Ty> struct is_default_constructible : is_constructible<_Ty>::type {
};
    template <class _Ty> struct has_default_constructor : is_default_constructible<_Ty>::type {
};
    template <bool, class _To, class _From> struct _Is_assignable : false_type {
 };
    template <class _To, class _From> struct is_assignable : _If<     is_void<_To>::value &&is_void<_From>::value ||         is_scalar<_To>::value &&is_scalar<_From>::value,     true_type,     typename _Is_assignable<         is_object<typename remove_reference<_To>::type>::value &&             !is_array<typename remove_reference<_To>::type>::value &&                  is_object<typename remove_reference<_From>::type>::value &&             !is_array<typename remove_reference<_From>::type>::value,         _To, _From>::type>::type {
};
    template <class _Ty> struct is_copy_assignable : is_assignable<     typename add_lvalue_reference<typename remove_volatile<_Ty>::type>::type,     typename add_lvalue_reference<typename add_const<         typename remove_volatile<_Ty>::type>::type>::type>::type {
};
    template <class _Ty> struct is_move_assignable : is_assignable<     typename add_lvalue_reference<typename remove_volatile<_Ty>::type>::type,     typename remove_volatile<_Ty>::type>::type {
};
    template <class _Ty> struct has_move_assign : is_move_assignable<_Ty>::type {
};
    template <class, class = _Nil, class _V0_t = _Nil, class _V1_t = _Nil,           class _V2_t = _Nil, class _V3_t = _Nil, class _V4_t = _Nil,           class _V5_t = _Nil, class _V6_t = _Nil, class _V7_t = _Nil,           class _V8_t = _Nil, class _V9_t = _Nil, class _V10_t = _Nil,           class = _Nil> struct is_trivially_constructible;
    template <class _Ty, class _Xarg0> struct is_trivially_constructible<_Ty, _Xarg0, _Nil, _Nil, _Nil, _Nil, _Nil,                                   _Nil, _Nil, _Nil, _Nil, _Nil,                                   _Nil> : is_constructible<_Ty, _Xarg0> {
};
    template <class _Ty> struct is_trivially_default_constructible     : is_trivially_constructible<_Ty>::type {
};
    template <class, class = _Nil, class _V0_t = _Nil, class _V1_t = _Nil,           class _V2_t = _Nil, class _V3_t = _Nil, class _V4_t = _Nil,           class _V5_t = _Nil, class _V6_t = _Nil, class _V7_t = _Nil,           class _V8_t = _Nil, class _V9_t = _Nil, class _V10_t = _Nil,           class = _Nil> struct is_nothrow_constructible;
    template <class _Ty, class _Xarg0> struct is_nothrow_constructible<_Ty, _Xarg0, _Nil, _Nil, _Nil, _Nil, _Nil, _Nil,                                 _Nil, _Nil, _Nil, _Nil,                                 _Nil> : is_constructible<_Ty, _Xarg0> {
};
    template <class _Ty, class _Xarg0, class _V0_t, class _V1_t> struct is_nothrow_constructible<     _Ty, _Xarg0, _V0_t, _V1_t, _Nil, _Nil, _Nil, _Nil, _Nil, _Nil, _Nil, _Nil,     _Nil> : is_constructible<_Ty, _Xarg0, _V0_t, _V1_t> {
};
    template <class _Ty> struct has_nothrow_copy     : _Cat_base<is_pod<typename remove_reference<_Ty>::type>::value ||                 __has_nothrow_copy(typename remove_reference<_Ty>::type)> {
};
    template <class _Ty>     struct _Has_signed_vals     : _Cat_base <       (typename remove_cv<_Ty>::type)(-1)<(typename remove_cv<_Ty>::type)(0)> {
 };
    template <class _Ty> struct is_signed     : _Cat_base<is_floating_point<_Ty>::value ||                 is_integral<_Ty>::value &&_Has_signed_vals<typename _If<                     is_integral<_Ty>::value, _Ty, int>::type>::value> {
};
    template <class _Ty> struct _Change_sign {
   static_assert(       ((is_integral<_Ty>::value || is_enum<_Ty>::value) &&        !is_same<_Ty, bool>::value),       "make_signed<T>/make_unsigned<T> require that T shall be a (possibly "       "cv-qualified) integral type or enumeration but not a bool type.");
   typedef typename _If < is_same<_Ty, signed char>::value ||       is_same<_Ty, unsigned char>::value,       signed char, typename _If < is_same<_Ty, short>::value ||                        is_same<_Ty, unsigned short>::value,       short, typename _If < is_same<_Ty, int>::value ||                  is_same<_Ty, unsigned int>::value,       int, typename _If < is_same<_Ty, long>::value ||                is_same<_Ty, unsigned long>::value,       long, typename _If < is_same<_Ty, long long>::value ||                 is_same<_Ty, unsigned long long>::value,       long long,       typename _If<           sizeof(_Ty) == sizeof(signed char), signed char,           typename _If<               sizeof(_Ty) == sizeof(short), short,               typename _If<sizeof(_Ty) == sizeof(int), int,                            typename _If<sizeof(_Ty) == sizeof(long), long,                                         long long>::type>::type>::type>::type >           ::type > ::type > ::type > ::type > ::type _Signed;
   typedef typename _If<       is_same<_Signed, signed char>::value, unsigned char,       typename _If<           is_same<_Signed, short>::value, unsigned short,           typename _If<               is_same<_Signed, int>::value, unsigned int,               typename _If<is_same<_Signed, long>::value, unsigned long,                            unsigned long long>::type>::type>::type>::type       _Unsigned;
 };
    template <class _Ty> struct _Change_sign<const _Ty> {
 };
    template <class _Ty> struct make_unsigned {
 };
    template <class _Ty> struct _Get_align {
 };
    template <class _Ty> struct alignment_of     : integral_constant<size_t, (sizeof(_Get_align<_Ty>) - 2 * sizeof(_Ty))> {
};
    template <class _Ty, size_t _Len> union _Align_type {
 };
    template <size_t _Len, size_t _Align, class _Ty, bool _Ok> struct _Aligned;
    template <size_t _Len, size_t _Align, class _Ty> struct _Aligned<_Len, _Align, _Ty, true> {
   typedef _Align_type<_Ty, _Len> type;
 };
    template <size_t _Len, size_t _Align = alignment_of<max_align_t>::value> struct aligned_storage {
   typedef typename _Aligned<       _Len, _Align, char,       _Align <= (sizeof(_Get_align<char>) - 2 * sizeof(char))>::type type;
 };
    template <size_t _Len, class = _Nil, class _V0_t = _Nil, class _V1_t = _Nil,           class _V2_t = _Nil, class _V3_t = _Nil, class _V4_t = _Nil,           class _V5_t = _Nil, class _V6_t = _Nil, class _V7_t = _Nil,           class _V8_t = _Nil, class _V9_t = _Nil, class _V10_t = _Nil,           class = _Nil> struct aligned_union;
    template <size_t _Len> struct aligned_union<_Len, _Nil, _Nil, _Nil, _Nil, _Nil, _Nil, _Nil, _Nil, _Nil,                      _Nil, _Nil, _Nil, _Nil> {
 };
    template <size_t _Len, class _Xty0> struct aligned_union<_Len, _Xty0, _Nil, _Nil, _Nil, _Nil, _Nil, _Nil, _Nil,                      _Nil, _Nil, _Nil, _Nil> {
   typedef union {     typename aligned_storage<         _Len, (sizeof(_Get_align<_Xty0>) - 2 * sizeof(_Xty0))>::type _Obj1;     typename aligned_union<_Len>::type _Obj2;   }
 type;
 };
    template <size_t _Len, class _Xty0, class _V0_t> struct aligned_union<_Len, _Xty0, _V0_t, _Nil, _Nil, _Nil, _Nil, _Nil, _Nil,                      _Nil, _Nil, _Nil, _Nil> {
};
    template <class _Ty, unsigned int _Nx> struct _Extent : integral_constant<size_t, 0> {
};
    template <class _Ty, unsigned int _Ix> struct _Extent<_Ty[_Ix], 0> : integral_constant<size_t, _Ix> {
};
    template <class _Ty> struct decay {
 };
    namespace tr1 {
 using ::std::add_const;
 using ::std::true_type;
 }
    template <bool, class _Ty0, class _Ty1> struct _Common_type {
   typedef void type;
 };
    template <class, class = _Nil, class _V0_t = _Nil, class _V1_t = _Nil,           class _V2_t = _Nil, class _V3_t = _Nil, class _V4_t = _Nil,           class _V5_t = _Nil, class _V6_t = _Nil, class _V7_t = _Nil,           class _V8_t = _Nil, class _V9_t = _Nil, class _V10_t = _Nil,           class = _Nil> struct common_type;
    template <class _Xty0> struct common_type<_Xty0, _Nil, _Nil, _Nil, _Nil, _Nil, _Nil, _Nil, _Nil, _Nil,                    _Nil, _Nil, _Nil, _Nil> {
   typedef _Xty0 type;
 };
    template <class _Xty0, class _Xty1, class _V0_t, class _V1_t, class _V2_t,           class _V3_t, class _V4_t, class _V5_t, class _V6_t, class _V7_t,           class _V8_t, class _V9_t> struct common_type<_Xty0, _Xty1, _V0_t, _V1_t, _V2_t, _V3_t, _V4_t, _V5_t,                    _V6_t, _V7_t, _V8_t, _V9_t, _Nil> {
   typedef typename _Common_type<       _Is_numeric<_Xty0>::value &&_Is_numeric<_Xty1>::value, _Xty0, _Xty1>::type       _Xty01;
 };
    template <class _Ty> class reference_wrapper;
    template <class _Ty> struct _Unrefwrap_helper {
   typedef _Ty type;
 };
    template <class _Ty> struct _Unrefwrap {
 };
    template <class _Ty> inline _Ty &&forward(typename remove_reference<_Ty>::type &_Arg) {
 }
    template <class _Ty> inline typename remove_reference<_Ty>::type &&move(_Ty &&_Arg) throw() {
 }
    }
    namespace std {
    template <class _Ty> inline void swap(_Ty &, _Ty &);
    template <class _FwdIt1, class _FwdIt2> inline void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right) {
   _Right = _Move(_Tmp);
 }
    template <class = _Nil, class _V0_t = _Nil, class _V1_t = _Nil,           class _V2_t = _Nil, class _V3_t = _Nil, class _V4_t = _Nil,           class _V5_t = _Nil, class _V6_t = _Nil, class _V7_t = _Nil,           class _V8_t = _Nil, class _V9_t = _Nil, class _V10_t = _Nil,           class = _Nil> class tuple;
    template <class _Ty1, class _Ty2> struct pair {
   _Ty1 first;
   _Ty2 second;
 };
    template <class _Ty1, class _Ty2> inline void swap(pair<_Ty1, _Ty2> &_Left, pair<_Ty1, _Ty2> &_Right) {
   _Left.swap(_Right);
 }
    template <class _Ty1, class _Ty2> inline pair<typename _Unrefwrap<_Ty1>::type, typename _Unrefwrap<_Ty2>::type> make_pair(_Ty1 &&_Val1, _Ty2 &&_Val2) {
   typedef pair<typename _Unrefwrap<_Ty1>::type, typename _Unrefwrap<_Ty2>::type>       _Mypair;
 }
    struct _Container_base0 {
   void _Orphan_all() {}
   void _Swap_all(_Container_base0 &) {}
 };
    struct _Iterator_base0 {
   void _Adopt(const void *) {}
 };
    struct _Container_base12;
    struct _Iterator_base12;
    struct _Container_proxy {
   _Container_proxy() : _Mycont(0), _Myfirstiter(0) {}
   const _Container_base12 *_Mycont;
   _Iterator_base12 *_Myfirstiter;
 };
    struct _Container_base12 {
   _Container_proxy *_Myproxy;
 };
    struct _Iterator_base12 {
 };
    typedef _Container_base0 _Container_base;
    typedef _Iterator_base0 _Iterator_base;
    template <class _Ty> struct _Get_unchecked_type {
 };
    template <class _Ty> struct _Is_checked_helper {
   template <class _Uty>   static auto _Fn(       int,       typename remove_reference<typename _Uty::_Unchecked_type>::type * = 0,       typename remove_reference<typename _Uty::_Unchecked_type>::type * = 0,       typename remove_reference<typename _Uty::_Unchecked_type>::type * = 0)       -> true_type;
   typedef decltype(_Fn<_Ty>(0)) type;
 };
    template <class _Iter> inline _Iter _Unchecked(_Iter _Src) {
   return (_Src);
 }
    template <class _Iter, class _UIter> inline _Iter &_Rechecked(_Iter &_Dest, _UIter _Src) {
 }
    struct input_iterator_tag {
};
    struct output_iterator_tag {
};
    struct forward_iterator_tag : public input_iterator_tag, output_iterator_tag {
};
    struct bidirectional_iterator_tag : public forward_iterator_tag {
};
    struct random_access_iterator_tag : public bidirectional_iterator_tag {
};
    struct _Nonscalar_ptr_iterator_tag {
};
    struct _Scalar_ptr_iterator_tag {
};
    template <class _Category, class _Ty, class _Diff = ptrdiff_t,           class _Pointer = _Ty *, class _Reference = _Ty &> struct iterator {
   typedef _Diff difference_type;
   typedef _Diff distance_type;
   typedef _Pointer pointer;
   typedef _Reference reference;
 };
    template <class _Category, class _Ty, class _Diff, class _Pointer,           class _Reference, class _Base> struct _Iterator012 : public _Base {
   typedef _Reference reference;
 };
    struct _Outit : public iterator<output_iterator_tag, void, void, void, void> {
};
    template <class _Iter> struct iterator_traits {
 };
    template <class _Ty> struct iterator_traits<_Ty *> {
   typedef random_access_iterator_tag iterator_category;
 };
    template <class _Iter> inline typename iterator_traits<_Iter>::iterator_category _Iter_cat(     const _Iter &) {
   typename iterator_traits<_Iter>::iterator_category _Cat;
   return (_Cat);
 }
    template <class _Elem1, class _Elem2> struct _Ptr_cat_helper {
   typedef _Nonscalar_ptr_iterator_tag type;
 };
    template <class _Elem> struct _Ptr_cat_helper<_Elem, _Elem> {
   typedef typename _If<is_scalar<_Elem>::value, _Scalar_ptr_iterator_tag,                        _Nonscalar_ptr_iterator_tag>::type type;
 };
    template <class _Elem1, class _Elem2> inline typename _Ptr_cat_helper<_Elem1, _Elem2>::type _Ptr_cat(_Elem1 *,                                                                _Elem2 *) {
   typename _Ptr_cat_helper<_Elem1, _Elem2>::type _Cat;
   return (_Cat);
 }
    template <class _Elem1, class _Elem2> inline typename _Ptr_cat_helper<_Elem1, _Elem2>::type _Ptr_cat(const _Elem1 *,                                                                _Elem2 *) {
 }
    template <class _Iter> inline typename iterator_traits<_Iter>::value_type *_Val_type(_Iter) {
   return (0);
 --_Off) ++_Where;
 }
    template <class _FwdIt, class _Diff> inline void _Advance(_FwdIt &_Where, _Diff _Off, forward_iterator_tag) {
 ++_First) ++_Off;
 }
    template <class _InIt> inline typename iterator_traits<_InIt>::difference_type distance(_InIt _First,                                                                  _InIt _Last) {
 }
    template <class _Ty> struct pointer_traits;
    template <class _RanIt, class _Base> class _Revranit : public _Base {
 };
    template <class _RanIt, class _Base, class _Diff> inline _Revranit<_RanIt, _Base> operator+(     _Diff _Off, const _Revranit<_RanIt, _Base> &_Right) {
   return (_Right + _Off);
 }
    template <class _RanIt1, class _Base1, class _RanIt2, class _Base2> inline bool operator==(const _Revranit<_RanIt1, _Base1> &_Left,                        const _Revranit<_RanIt2, _Base2> &_Right) {
   return (_Left._Equal(_Right));
 }
    template <class _RanIt> class reverse_iterator : public _Revranit<     _RanIt, iterator<typename iterator_traits<_RanIt>::iterator_category,                      typename iterator_traits<_RanIt>::value_type,                      typename iterator_traits<_RanIt>::difference_type,                      typename iterator_traits<_RanIt>::pointer,                      typename iterator_traits<_RanIt>::reference> > {
   typedef reverse_iterator<_RanIt> _Myt;
 };
    template <class _RanIt1, class _RanIt2> inline bool operator!=(const reverse_iterator<_RanIt1> &_Left,                        const reverse_iterator<_RanIt2> &_Right) {
   return (!(_Left == _Right));
 }
    template <class _RanIt1, class _RanIt2> inline bool operator<(const reverse_iterator<_RanIt1> &_Left,                       const reverse_iterator<_RanIt2> &_Right) {
   return (_Left._Less(_Right));
 }
    template <class _Ty, size_t _Size> class _Array_const_iterator     : public _Iterator012<random_access_iterator_tag, _Ty, ptrdiff_t,                           const _Ty *, const _Ty &, _Iterator_base> {
 };
    template <class _Ty, size_t _Size> inline typename _Array_const_iterator<_Ty, _Size>::_Unchecked_type _Unchecked(     _Array_const_iterator<_Ty, _Size> _Iter) {
   return (_Iter._Unchecked());
   reference operator[](difference_type _Off) const { return (*(*this + _Off)); }
 };
    template <class _RanIt> class move_iterator {
};
    template <class _RanIt, class _Diff> inline move_iterator<_RanIt> operator+(_Diff _Off,                                        const move_iterator<_RanIt> &_Right) {
   return (_Right + _Off);
   return (!(_Left == _Right));
 }
    template <class _Ty> inline const _Ty &(min)(const _Ty &_Left, const _Ty &_Right) {
   return (((_Right) < (_Left)) ? _Right : _Left);
 }
    template <class _InIt, class _OutIt> inline _OutIt _Move(_InIt _First, _InIt _Last, _OutIt _Dest,                     _Scalar_ptr_iterator_tag) {
   ptrdiff_t _Count = _Last - _First;
   return (_Dest + _Count);
 }
    template <class _InIt, class _OutIt> inline _OutIt _Move(_InIt _First, _InIt _Last, _OutIt _Dest) {
   return (_Move(_First, _Last, _Dest, _Ptr_cat(_First, _Dest)));
 }
    template <class _BidIt1, class _BidIt2> inline _BidIt2 _Move_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest,                               _Nonscalar_ptr_iterator_tag) {
 }
    template <class _InIt, class _Ty> inline _InIt _Find(_InIt _First, _InIt _Last, const _Ty &_Val) {
   for (;
   return (_First == 0 ? _Last : _First);
 }
    inline const unsigned char *_Find(const unsigned char *_First,                                   const unsigned char *_Last, int _Val) {
 }
    template <class _InIt, class _Ty> inline _InIt find(_InIt _First, _InIt _Last, const _Ty &_Val) {
   ;
   ::std::reverse(_First, _Last);
 }
    template <class _RanIt, class _Diff, class _Ty> inline void _Rotate(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Diff *, _Ty *) {
 }
    template <class _FwdIt> inline _FwdIt rotate(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last) {
   ;
   return (_First);
 }
    template <class _Diff, class _Urng> class _Rng_from_urng {
  public:   typedef typename make_unsigned<_Diff>::type _Ty0;
   _Rng_from_urng &operator=(const _Rng_from_urng &);
 };
    template <class _Elem> class _Yarn {
 };
    template <class _Ty, class _Alloc> struct _Has_allocator_type {
   template <class _Uty>   static auto _Fn(int) -> is_convertible<_Alloc, typename _Uty::allocator_type>;
   typedef decltype(_Fn<_Ty>(0)) type;
 };
    __declspec(noreturn) void __cdecl _Xinvalid_argument(const char *);
    __declspec(noreturn) void __cdecl _Xlength_error(const char *);
    __declspec(noreturn) void __cdecl _Xout_of_range(const char *);
    }
    namespace std {
    template <class _Ty, class _Alloc> struct uses_allocator : _Has_allocator_type<_Ty, _Alloc>::type {
};
    }
    namespace std {
    template <class _Ty> inline _Ty *_Allocate(size_t _Count, _Ty *) {
 }
    template <class _Ty> inline void _Destroy(_Ty *_Ptr) {
   _Ptr->~_Ty();
 }
    template <> inline void _Destroy(wchar_t *) {
}
    template <class _Alloc> inline void _Destroy_range(typename _Alloc::pointer _First,                            typename _Alloc::pointer _Last, _Alloc &_Al) {
   _Destroy_range(_First, _Last, _Al, _Ptr_cat(_First, _Last));
 }
    template <class _Alloc> inline void _Destroy_range(typename _Alloc::pointer _First,                            typename _Alloc::pointer _Last, _Alloc &_Al,                            _Nonscalar_ptr_iterator_tag) {
 }
    template <class _Alloc> inline void _Destroy_range(typename _Alloc::pointer _First,                            typename _Alloc::pointer _Last, _Alloc &_Al,                            _Scalar_ptr_iterator_tag) {
}
    template <class _Alty> struct _Is_simple_alloc : _Cat_base<     is_same<typename _Alty::size_type, size_t>::value &&         is_same<typename _Alty::difference_type, ptrdiff_t>::value &&is_same<             typename _Alty::pointer, typename _Alty::value_type *>::value &&             is_same<typename _Alty::const_pointer,                     const typename _Alty::value_type *>::value &&                 is_same<typename _Alty::reference,                         typename _Alty::value_type &>::value &&                     is_same<typename _Alty::const_reference,                             const typename _Alty::value_type &>::value> {
};
    template <class _Value_type> struct _Simple_types {
   typedef _Value_type value_type;
   typedef size_t size_type;
   typedef ptrdiff_t difference_type;
   typedef value_type *pointer;
   typedef const value_type *const_pointer;
   typedef value_type &reference;
   typedef const value_type &const_reference;
 };
    template <class _Alty, class _Pointer> struct _Get_voidptr {
   typedef void *type;
 };
    template <class _Iter> struct _Is_iterator     : public integral_constant<bool, !is_integral<_Iter>::value> {
};
    template <class _Ty> struct pointer_traits;
    template <class _Ty> struct _Get_first_parameter {
   typedef typename _Ty::element_type type;
 };
    template <class _Newfirst, class _Ty> struct _Replace_first_parameter {
   typedef typename _Ty::template rebind<_Newfirst>::other type;
 };
    template <class _Ty> struct _Get_element_type {
 };
    template <class _Ty> struct _Get_ptr_difference_type {
 };
    template <class _Ty, class _Other> struct _Get_rebind_type {
   template <class _Uty>   static auto _Fn(int) -> typename _Uty::template rebind<_Other>::other;
   typedef decltype(_Fn<_Ty>(0)) type;
 };
    template <class _Ty> struct pointer_traits {
 };
    template <class _Ty> struct _Get_pointer_type {
   template <class _Uty>   static auto _Fn(int) -> typename _Uty::pointer;
   typedef decltype(_Fn<_Ty>(0)) type;
 };
    template <class _Ty> struct _Get_difference_type {
   template <class _Uty>   static auto _Fn(int) -> typename _Uty::difference_type;
   template <class _Uty>   static auto _Fn(_Wrap_int) -> typename _Get_ptr_difference_type<       typename _Get_pointer_type<_Ty>::type>::type;
   typedef decltype(_Fn<_Ty>(0)) type;
 };
    struct _Alloc_allocate {
   template <class _Ty>   static auto _Fn(_Wrap_int, const _Ty &_Al) -> _Ty {     return (_Al);   }
 };
    template <class _Alloc> struct allocator_traits {
 };
    template <class _Ty> struct _Allocator_base {
   typedef _Ty value_type;
 };
    template <class _Ty> class allocator : public _Allocator_base<_Ty> {
  public:   typedef allocator<_Ty> other;
   typedef _Allocator_base<_Ty> _Mybase;
   typedef typename _Mybase::value_type value_type;
   typedef value_type *pointer;
   typedef const value_type *const_pointer;
   typedef void *void_pointer;
   typedef const void *const_void_pointer;
   typedef value_type &reference;
   typedef const value_type &const_reference;
   typedef size_t size_type;
   void deallocate(pointer _Ptr, size_type) { ::operator delete(_Ptr); }
   pointer allocate(size_type _Count) { return (_Allocate(_Count, (pointer)0)); }
   pointer allocate(size_type _Count, const void *) {     return (allocate(_Count));   }
   template <class _Objty, class _V0_t>   void construct(_Objty *_Ptr, _V0_t &&_V0) {     ::new ((void *)_Ptr) _Objty(::std::forward<_V0_t>(_V0));   }
   template <class _Uty>   void destroy(_Uty *_Ptr) {     _Ptr->~_Uty();   }
   size_t max_size() const { return ((size_t)(-1) / sizeof(_Ty)); }
 };
    template <> class allocator<void> {
 };
    template <class _Ty, class _Other> inline bool operator==(const allocator<_Ty> &, const allocator<_Other> &) {
   return (true);
   return (!(_Left == _Right));
 }
    template <class _Ty> struct allocator_traits<allocator<_Ty> > {
   typedef allocator<_Ty> _Alloc;
   typedef allocator_traits<_Alloc> other;
   typedef typename _Alloc::value_type value_type;
   typedef value_type *pointer;
   typedef size_t size_type;
   typedef ptrdiff_t difference_type;
   typedef false_type propagate_on_container_copy_assignment;
   typedef false_type propagate_on_container_swap;
   template <class _Other>   struct rebind_alloc {     typedef allocator<_Other> other;   };
   static size_type max_size(const _Alloc &_Al) { return (_Al.max_size()); }
   static _Alloc select_on_container_copy_construction(const _Alloc &_Al) {     return (_Al.select_on_container_copy_construction());   }
 };
    template <class _Alloc> struct _Wrap_alloc : public _Alloc {
   typedef _Wrap_alloc<_Alloc> other;
   typedef allocator_traits<_Alloc> _Mytraits;
   typedef typename _Mytraits::value_type value_type;
   typedef typename _Mytraits::size_type size_type;
   typedef typename _Mytraits::difference_type difference_type;
   _Wrap_alloc select_on_container_copy_construction() const {     return (_Mytraits::select_on_container_copy_construction(*this));   }
   template <class _Other>   struct rebind {     typedef typename _Mytraits::template rebind_alloc<_Other>::other         _Other_alloc;     typedef _Wrap_alloc<_Other_alloc> other;   };
   size_type max_size() const { return (_Mytraits::max_size(*this)); }
 };
    template <class _Mystr> class _String_const_iterator : public _Iterator012<     random_access_iterator_tag, typename _Mystr::value_type,     typename _Mystr::difference_type, typename _Mystr::const_pointer,     typename _Mystr::const_reference, _Iterator_base> {
 };
    template <class _Mystr> inline typename _String_const_iterator<_Mystr>::_Unchecked_type _Unchecked(     _String_const_iterator<_Mystr> _Iter) {
 }
    template <class _Mystr> class _String_iterator : public _String_const_iterator<_Mystr> {
   typedef typename _Mystr::difference_type difference_type;
   typedef typename _Mystr::pointer pointer;
   typedef typename _Mystr::reference reference;
   reference operator[](difference_type _Off) const { return (*(*this + _Off)); }
 };
    template <class _Mystr> inline typename _String_iterator<_Mystr>::_Unchecked_type _Unchecked(     _String_iterator<_Mystr> _Iter) {
   return (_Iter._Unchecked());
 }
    template <class _Value_type, class _Size_type, class _Difference_type,           class _Pointer, class _Const_pointer, class _Reference,           class _Const_reference> struct _String_iter_types {
   typedef _Value_type value_type;
 };
    template <class _Ty, class _Alloc0> struct _String_base_types {
   typedef _Alloc0 _Alloc;
   typedef _Wrap_alloc<_Alloc> _Alty0;
   typedef typename _Alty0::template rebind<_Ty>::other _Alty;
   typedef typename _If<       _Is_simple_alloc<_Alty>::value, _Simple_types<typename _Alty::value_type>,       _String_iter_types<typename _Alty::value_type, typename _Alty::size_type,                          typename _Alty::difference_type,                          typename _Alty::pointer, typename _Alty::const_pointer,                          typename _Alty::reference,                          typename _Alty::const_reference> >::type _Val_types;
 };
    template <class _Val_types> class _String_val : public _Container_base {
  public:   typedef _String_val<_Val_types> _Myt;
   typedef typename _Val_types::value_type value_type;
   typedef typename _Val_types::size_type size_type;
   typedef typename _Val_types::difference_type difference_type;
   typedef typename _Val_types::pointer pointer;
   typedef typename _Val_types::const_pointer const_pointer;
   typedef typename _Val_types::reference reference;
   typedef typename _Val_types::const_reference const_reference;
   typedef _String_iterator<_Myt> iterator;
   typedef _String_const_iterator<_Myt> const_iterator;
   _String_val() {     _Mysize = 0;     _Myres = 0;   }
   enum {     _BUF_SIZE = 16 / sizeof(value_type) < 1 ? 1 : 16 / sizeof(value_type)   };
   enum {     _ALLOC_MASK = sizeof(value_type) <= 1                       ? 15                       : sizeof(value_type) <= 2                             ? 7                             : sizeof(value_type) <= 4                                   ? 3                                   : sizeof(value_type) <= 8 ? 1 : 0   };
   value_type *_Myptr() {     return (this->_BUF_SIZE <= this->_Myres ? ::std::addressof(*this->_Bx._Ptr)                                             : this->_Bx._Buf);   }
   const value_type *_Myptr() const {     return (this->_BUF_SIZE <= this->_Myres ? ::std::addressof(*this->_Bx._Ptr)                                             : this->_Bx._Buf);   }
   union _Bxty {     value_type _Buf[_BUF_SIZE];     pointer _Ptr;     char _Alias[_BUF_SIZE];   }
 _Bx;
   size_type _Mysize;
   size_type _Myres;
 };
    template <bool _Al_has_storage, class _Alloc_types> class _String_alloc : public _String_val<typename _Alloc_types::_Val_types> {
  public:   typedef _String_alloc<_Al_has_storage, _Alloc_types> _Myt;
   typedef typename _Alloc_types::_Alloc _Alloc;
   typedef typename _Alloc_types::_Alty _Alty;
   void _Swap_alloc(_Myt &) {}
   _Alty _Getal() const { return (_Alty()); }
 };
    template <class _Elem, class _Traits, class _Alloc> class basic_string : public _String_alloc<!is_empty<_Alloc>::value,                                           _String_base_types<_Elem, _Alloc> > {
  public:   typedef basic_string<_Elem, _Traits, _Alloc> _Myt;
   typedef _String_alloc<!is_empty<_Alloc>::value,                         _String_base_types<_Elem, _Alloc> > _Mybase;
   typedef typename _Mybase::value_type value_type;
   typedef typename _Mybase::size_type size_type;
   typedef typename _Mybase::pointer pointer;
   typedef typename _Mybase::const_pointer const_pointer;
   typedef typename _Mybase::const_reference const_reference;
   typedef typename _Mybase::iterator iterator;
   typedef typename _Mybase::const_iterator const_iterator;
   basic_string(const _Myt &_Right, const _Alloc &_Al) : _Mybase(_Al) {     _Tidy();     assign(_Right, 0, npos);   }
   basic_string() : _Mybase() { _Tidy(); }
   basic_string(const _Elem *_Ptr, size_type _Count) : _Mybase() {     _Tidy();     assign(_Ptr, _Count);   }
   basic_string(const _Elem *_Ptr, size_type _Count, const _Alloc &_Al)       : _Mybase(_Al) {     _Tidy();     assign(_Ptr, _Count);   }
   basic_string(const _Elem *_Ptr) : _Mybase() {     _Tidy();     assign(_Ptr);   }
   ~basic_string() throw() { _Tidy(true); }
   static const size_type npos;
   _Myt &assign(const _Myt &_Right) { return (assign(_Right, 0, npos)); }
   _Myt &assign(const _Myt &_Right, size_type _Roff, size_type _Count) {     if (_Right.size() < _Roff) _Xran();     size_type _Num = _Right.size() - _Roff;     if (_Count < _Num) _Num = _Count;     if (this == &_Right)       erase((size_type)(_Roff + _Num)), erase(0, _Roff);     else if (_Grow(_Num)) {       _Traits::copy(this->_Myptr(), _Right._Myptr() + _Roff, _Num);       _Eos(_Num);     }     return (*this);   }
   _Myt &assign(const _Elem *_Ptr, size_type _Count) {     if (_Inside(_Ptr)) return (assign(*this, _Ptr - this->_Myptr(), _Count));     if (_Grow(_Count)) {       _Traits::copy(this->_Myptr(), _Ptr, _Count);       _Eos(_Count);     }     return (*this);   }
   _Myt &erase(size_type _Off = 0) {     if (this->_Mysize < _Off) _Xran();     _Eos(_Off);     return (*this);   }
   _Myt &erase(size_type _Off, size_type _Count) {     if (this->_Mysize < _Off) _Xran();     if (this->_Mysize - _Off <= _Count)       _Eos(_Off);     else if (0 < _Count) {       value_type *_Ptr = this->_Myptr() + _Off;       size_type _Newsize = this->_Mysize - _Count;       _Traits::move(_Ptr, _Ptr + _Count, _Newsize - _Off);       _Eos(_Newsize);     }     return (*this);   }
   iterator erase(const_iterator _Where) {     size_type _Count = _Pdif(_Where, begin());     erase(_Count, 1);     return (iterator(this->_Myptr() + _Count, this));   }
   const_reference back() const { return (*(end() - 1)); }
   const _Elem *c_str() const throw() { return (this->_Myptr()); }
   const _Elem *data() const throw() { return (c_str()); }
   size_type length() const throw() { return (this->_Mysize); }
   size_type size() const throw() { return (this->_Mysize); }
   size_type max_size() const throw() {     size_type _Num = this->_Getal().max_size();     return (_Num <= 1 ? 1 : _Num - 1);   }
   void _Copy(size_type _Newsize, size_type _Oldlen) {     size_type _Newres = _Newsize | this->_ALLOC_MASK;     if (max_size() < _Newres)       _Newres = _Newsize;     else if (this->_Myres / 2 <= _Newres / 3)       ;     else if (this->_Myres <= max_size() - this->_Myres / 2)       _Newres = this->_Myres + this->_Myres / 2;     else       _Newres = max_size();     _Elem *_Ptr;     {       { _Ptr = this->_Getal().allocate(_Newres + 1); }       if (0) {         _Newres = _Newsize;         {           { _Ptr = this->_Getal().allocate(_Newres + 1); }           if (0) {             _Tidy(true);             ;           }         }       }     }     if (0 < _Oldlen) _Traits::copy(_Ptr, this->_Myptr(), _Oldlen);     _Tidy(true);     this->_Getal().construct(&this->_Bx._Ptr, _Ptr);     this->_Myres = _Newres;     _Eos(_Oldlen);   }
   void _Eos(size_type _Newsize) {     _Traits::assign(this->_Myptr()[this->_Mysize = _Newsize], _Elem());   }
   bool _Grow(size_type _Newsize, bool _Trim = false) {     if (max_size() < _Newsize) _Xlen();     if (this->_Myres < _Newsize)       _Copy(_Newsize, this->_Mysize);     else if (_Trim && _Newsize < this->_BUF_SIZE)       _Tidy(true, _Newsize < this->_Mysize ? _Newsize : this->_Mysize);     else if (_Newsize == 0)       _Eos(0);     return (0 < _Newsize);   }
   bool _Inside(const _Elem *_Ptr) {     if (_Ptr == 0 || _Ptr < this->_Myptr() ||         this->_Myptr() + this->_Mysize <= _Ptr)       return (false);     else       return (true);   }
   static size_type _Pdif(const_iterator _P2, const_iterator _P1) {     return ((_P2)._Ptr == 0 ? 0 : _P2 - _P1);   }
   void _Tidy(bool _Built = false, size_type _Newsize = 0) {     if (!_Built)       ;     else if (this->_BUF_SIZE <= this->_Myres) {       pointer _Ptr = this->_Bx._Ptr;       this->_Getal().destroy(&this->_Bx._Ptr);       if (0 < _Newsize)         _Traits::copy(this->_Bx._Buf, ::std::addressof(*_Ptr), _Newsize);       this->_Getal().deallocate(_Ptr, this->_Myres + 1);     }     this->_Myres = this->_BUF_SIZE - 1;     _Eos(_Newsize);   }
   __declspec(noreturn) void _Xlen() const { _Xlength_error("string too long"); }
   __declspec(noreturn) void _Xran() const {     _Xout_of_range("invalid string position");   }
 };
    template <class _Elem, class _Traits, class _Alloc> const typename basic_string<_Elem, _Traits, _Alloc>::size_type     basic_string<_Elem, _Traits, _Alloc>::npos =         (typename basic_string<_Elem, _Traits, _Alloc>::size_type)(-1);
    template <class _Elem, class _Traits, class _Alloc> inline void swap(basic_string<_Elem, _Traits, _Alloc> &_Left,                  basic_string<_Elem, _Traits, _Alloc> &_Right) {
 }
    typedef basic_string<char, char_traits<char>, allocator<char> > string;
    template <class _Ty> inline pair<_Ty *, ptrdiff_t> get_temporary_buffer(ptrdiff_t _Count) throw() {
   _Ty *_Pbuf;
 }
    template <class _InIt, class _FwdIt> inline _FwdIt _Uninitialized_copy0(_InIt _First, _InIt _Last, _FwdIt _Dest) {
   return (_Uninitialized_copy0(_First, _Last, _Dest, _Ptr_cat(_First, _Dest)));
   return (_Rechecked(_Dest,                      _Uninitialized_copy0(_Unchecked(_First), _Unchecked(_Last),                                           _Unchecked(_Dest))));
 }
    template <class _InIt, class _FwdIt, class _Alloc> inline _FwdIt _Uninit_copy(_InIt _First, _InIt _Last, _FwdIt _Dest,                            _Wrap_alloc<_Alloc> &_Al,                            _Nonscalar_ptr_iterator_tag) {
 }
    template <class _InIt, class _FwdIt, class _Alloc> inline _FwdIt _Uninit_copy(_InIt _First, _InIt _Last, _FwdIt _Dest,                            _Wrap_alloc<_Alloc> &_Al, _Scalar_ptr_iterator_tag) {
   return (       _Uninit_copy(_First, _Last, _Dest, _Al, _Nonscalar_ptr_iterator_tag()));
 }
    template <class _InIt, class _FwdIt, class _Alloc> inline _FwdIt _Uninitialized_copy(_InIt _First, _InIt _Last, _FwdIt _Dest,                                   _Alloc &_Al) {
   return (_Uninit_copy(_First, _Last, _Dest, _Al, _Ptr_cat(_First, _Dest)));
 }
    template <class _InIt, class _FwdIt, class _Alloc, class _Valty> inline _FwdIt _Uninit_move(_InIt _First, _InIt _Last, _FwdIt _Dest,                            _Wrap_alloc<_Alloc> &_Al, _Valty *,                            _Nonscalar_ptr_iterator_tag) {
   ;
 }
    template <class _InIt, class _FwdIt, class _Alloc> inline _FwdIt _Uninitialized_move(_InIt _First, _InIt _Last, _FwdIt _Dest,                                   _Alloc &_Al) {
 }
    template <class _Ty, class _Diff, class _Tval, class _Valty> inline void _Uninit_fill_n(_Ty *_First, _Diff _Count, const _Tval *_Pval,                            _Wrap_alloc<allocator<_Ty> > &, _Valty *,                            _Scalar_ptr_iterator_tag) {
   _Fill_n(_First, _Count, *_Pval);
 }
    template <class _FwdIt, class _Diff, class _Alloc, class _Valty> inline void _Uninit_def_fill_n(_FwdIt _First, _Diff _Count,                                _Wrap_alloc<_Alloc> &_Al, _Valty *,                                _Nonscalar_ptr_iterator_tag) {
 };
    }
    typedef __int64 int64_t;
    typedef unsigned __int64 uint64_t;
    typedef signed int int32_t;
    typedef unsigned int uint32_t;
    namespace llvm {
    template <typename T> class PointerLikeTypeTraits {
};
    template <typename T> class PointerLikeTypeTraits<T *> {
  public:   static inline void *getAsVoidPointer(T *P) { return P; }
   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
   enum {     NumLowBitsAvailable = 2   };
 };
    template <typename T> class PointerLikeTypeTraits<const T *> {
   typedef PointerLikeTypeTraits<T *> NonConst;
  public:   static inline const void *getAsVoidPointer(const T *P) {     return NonConst::getAsVoidPointer(const_cast<T *>(P));   }
   static inline const T *getFromVoidPointer(const void *P) {     return NonConst::getFromVoidPointer(const_cast<void *>(P));   }
   enum {     NumLowBitsAvailable = NonConst::NumLowBitsAvailable   };
 };
    void __cdecl _wassert(const wchar_t *_Message, const wchar_t *_File,                       unsigned _Line);
    class SmallPtrSetImpl {
   friend class SmallPtrSetIteratorImpl;
  protected:   const void **SmallArray;
   const void **CurArray;
   unsigned CurArraySize;
   unsigned NumElements;
   unsigned NumTombstones;
   SmallPtrSetImpl(const void **SmallStorage, const SmallPtrSetImpl &that);
   explicit SmallPtrSetImpl(const void **SmallStorage, unsigned SmallSize)       : SmallArray(SmallStorage),         CurArray(SmallStorage),         CurArraySize(SmallSize) {     (void)((!!(SmallSize && (SmallSize & (SmallSize - 1)) == 0 &&                "Initial size must be a power of two!")) ||            (_wassert(L"SmallSize && (SmallSize & (SmallSize-1)) == 0 && "                      L"\"Initial size must be a power of two!\"",                      L"..\\include\\llvm/ADT/SmallPtrSet.h", 68),             0));     clear();   }
   void clear() {     if (!isSmall() && NumElements * 4 < CurArraySize && CurArraySize > 32)       return shrink_and_clear();     memset(CurArray, -1, CurArraySize * sizeof(void *));     NumElements = 0;     NumTombstones = 0;   }
  protected:   static void *getTombstoneMarker() { return reinterpret_cast<void *>(-2); }
   static void *getEmptyMarker() { return reinterpret_cast<void *>(-1); }
  private:   bool isSmall() const { return CurArray == SmallArray; }
   const void *const *FindBucketFor(const void *Ptr) const;
   void shrink_and_clear();
   void Grow(unsigned NewSize);
 };
    class SmallPtrSetIteratorImpl {
  protected:   const void *const *Bucket;
   const void *const *End;
  public:   explicit SmallPtrSetIteratorImpl(const void *const *BP, const void *const *E)       : Bucket(BP), End(E) {     AdvanceIfNotValid();   }
   bool operator!=(const SmallPtrSetIteratorImpl &RHS) const {     return Bucket != RHS.Bucket;   }
  protected:   void AdvanceIfNotValid() {     (void)((!!(Bucket <= End)) ||            (_wassert(L"Bucket <= End", L"..\\include\\llvm/ADT/SmallPtrSet.h",                      164),             0));     while (Bucket != End && (*Bucket == SmallPtrSetImpl::getEmptyMarker() ||                              *Bucket == SmallPtrSetImpl::getTombstoneMarker()))       ++Bucket;   }
 };
    template <typename PtrTy> class SmallPtrSetIterator : public SmallPtrSetIteratorImpl {
   typedef PointerLikeTypeTraits<PtrTy> PtrTraits;
 };
    template <unsigned N> struct RoundUpToPowerOfTwo;
    template <unsigned N, bool isPowerTwo> struct RoundUpToPowerOfTwoH {
   enum {     Val = N   };
 };
    template <unsigned N> struct RoundUpToPowerOfTwo {
   enum {     Val = RoundUpToPowerOfTwoH<N, (N &(N - 1)) == 0>::Val   };
 };
    template <class PtrType, unsigned SmallSize> class SmallPtrSet : public SmallPtrSetImpl {
   enum {     SmallSizePowTwo = RoundUpToPowerOfTwo<SmallSize>::Val   };
   const void *SmallStorage[SmallSizePowTwo];
   typedef PointerLikeTypeTraits<PtrType> PtrTraits;
  public:   SmallPtrSet() : SmallPtrSetImpl(SmallStorage, SmallSizePowTwo) {}
   void swap(SmallPtrSet<PtrType, SmallSize> &RHS) {     SmallPtrSetImpl::swap(RHS);   }
 };
    }
    namespace llvm {
    namespace sys {
 void MemoryFence();
 typedef long cas_flag;
 cas_flag CompareAndSwap(volatile cas_flag *ptr, cas_flag new_value,                         cas_flag old_value);
 cas_flag AtomicIncrement(volatile cas_flag *ptr);
 cas_flag AtomicDiv(volatile cas_flag *ptr, cas_flag val);
 }
    }
    extern "C" {
    void AnnotateHappensAfter(const char *file, int line, const volatile void *cv);
    }
    namespace llvm {
    class raw_ostream;
    class Statistic {
  public:   const char *Name;
   const char *Desc;
   volatile llvm::sys::cas_flag Value;
   bool Initialized;
   llvm::sys::cas_flag getValue() const { return Value; }
   const Statistic &operator=(unsigned Val) {     Value = Val;     return init();   }
   const Statistic &operator++() {     sys::AtomicIncrement(&Value);     return init();   }
  protected:   Statistic &init() {     bool tmp = Initialized;     sys::MemoryFence();     if (!tmp) RegisterStatistic();     AnnotateHappensAfter("..\\include\\llvm/ADT/Statistic.h", 156, this);     return *this;   }
   void RegisterStatistic();
 };
    namespace dont_use {
 template <typename T> char is_class_helper(void (T::*)());
 template <typename T> double is_class_helper(...);
 }
    template <typename T> struct is_class {
  public:   static const bool value =       sizeof(char) == sizeof(dont_use::is_class_helper<T>(0));
 };
    template <typename T> struct isPodLike {
   static const bool value = __is_trivially_copyable(T);
 };
    template <class T, T v> struct integral_constant {
   typedef T value_type;
   static const value_type value = v;
   operator value_type() { return value; }
 };
    typedef integral_constant<bool, true> true_type;
    typedef integral_constant<bool, false> false_type;
    template <typename T, typename U> struct is_same : public false_type {
};
    template <typename T> struct remove_const {
   typedef T type;
 };
    template <typename T> struct is_integral_impl : false_type {
};
    template <> struct is_integral_impl<unsigned long long> : true_type {
 };
    template <typename T> class is_integral_or_enum {
 };
    template <bool Cond, typename T = void> struct enable_if_c {
   typedef T type;
};
    namespace dont_use {
 template <typename Base> char base_of_helper(const volatile Base *);
 };
    template <typename T> struct remove_pointer {
   typedef T type;
 };
    template <typename T, typename Enable = void> struct add_lvalue_reference_if_not_pointer {
   typedef T &type;
 };
    template <typename T, typename Enable = void> struct add_const_past_pointer {
   typedef const T type;
 };
    template <bool, typename T, typename F> struct conditional {
   typedef T type;
 };
    template <typename T, typename F> struct conditional<false, T, F> {
   typedef F type;
 };
    template <typename T> struct DenseMapInfo {
};
    template <typename T> struct DenseMapInfo<T *> {
   static inline T *getEmptyKey() {     uintptr_t Val = static_cast<uintptr_t>(-1);     Val <<= PointerLikeTypeTraits<T *>::NumLowBitsAvailable;     return reinterpret_cast<T *>(Val);   }
   static inline T *getTombstoneKey() {     uintptr_t Val = static_cast<uintptr_t>(-2);     Val <<= PointerLikeTypeTraits<T *>::NumLowBitsAvailable;     return reinterpret_cast<T *>(Val);   }
   static unsigned getHashValue(const T *PtrVal) {     return (unsigned((uintptr_t)PtrVal) >> 4) ^            (unsigned((uintptr_t)PtrVal) >> 9);   }
   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
 };
    template <> struct DenseMapInfo<unsigned> {
   static inline unsigned getEmptyKey() { return ~0U; }
 };
    template <typename T> struct AlignmentCalcImpl {
   char x;
   T t;
 };
    template <typename T> struct AlignOf {
   enum {     Alignment =         static_cast<unsigned int>(sizeof(AlignmentCalcImpl<T>) - sizeof(T))   };
   enum {     Alignment_LessEqual_16Bytes = Alignment <= 16 ? 1 : 0   };
 };
    template <std::size_t Alignment, std::size_t Size> struct AlignedCharArray;
    template <std::size_t Size> struct AlignedCharArray<1, Size> {
   union {     char aligned;     char buffer[Size];   };
 };
    template <std::size_t Size> struct AlignedCharArray<4, Size> {
   union {     int aligned;     char buffer[Size];   };
 };
    template <std::size_t Size> struct AlignedCharArray<32, Size> {
   __declspec(align(32)) char buffer[Size];
 };
    namespace detail {
 template <typename T1, typename T2 = char, typename T3 = char,           typename T4 = char, typename T5 = char, typename T6 = char,           typename T7 = char> class AlignerImpl {   T1 t1;   T2 t2;   T3 t3;   T4 t4;   T5 t5;   T6 t6;   T7 t7;   AlignerImpl(); };
 template <typename T1, typename T2 = char, typename T3 = char,           typename T4 = char, typename T5 = char, typename T6 = char,           typename T7 = char> union SizerImpl {   char arr1[sizeof(T1)], arr2[sizeof(T2)], arr3[sizeof(T3)], arr4[sizeof(T4)],       arr5[sizeof(T5)], arr6[sizeof(T6)], arr7[sizeof(T7)]; };
 }
    template <typename T1, typename T2 = char, typename T3 = char,           typename T4 = char, typename T5 = char, typename T6 = char,           typename T7 = char> struct AlignedCharArrayUnion : llvm::AlignedCharArray<     AlignOf<detail::AlignerImpl<T1, T2, T3, T4, T5, T6, T7> >::Alignment,     sizeof(detail::SizerImpl<T1, T2, T3, T4, T5, T6, T7>)> {
};
    enum ZeroBehavior {
   ZB_Undefined,   ZB_Max,   ZB_Width };
    template <typename T> typename enable_if_c<     std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed,     std::size_t>::type countTrailingZeros(T Val, ZeroBehavior ZB = ZB_Width) {
   return ZeroBits;
 }
    template <> inline std::size_t countTrailingZeros<uint32_t>(uint32_t Val, ZeroBehavior ZB) {
   if (ZB != ZB_Undefined && Val == 0) return 32;
 }
    template <typename T> typename enable_if_c<     std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed,     std::size_t>::type countLeadingZeros(T Val, ZeroBehavior ZB = ZB_Width) {
   if (!Val) return std::numeric_limits<T>::digits;
 }
    template <unsigned N> inline bool isUInt(uint64_t x) {
   return N >= 64 || x < ((1ULL) << (N));
 }
    template <> inline bool isUInt<32>(uint64_t x) {
   return static_cast<uint32_t>(x) == x;
 }
    template <unsigned N, unsigned S> inline bool isShiftedUInt(uint64_t x) {
   return Value && !(Value & (Value - 1));
 }
    inline bool isPowerOf2_64(uint64_t Value) {
   return Value && !(Value & (Value - int64_t(1L)));
 }
    inline int32_t SignExtend32(uint32_t X, unsigned B) {
   return int32_t(X << (32 - B)) >> (32 - B);
 }
    }
    namespace llvm {
    template <typename KeyT, typename ValueT,           typename KeyInfoT = DenseMapInfo<KeyT>, bool IsConst = false> class DenseMapIterator;
    template <typename DerivedT, typename KeyT, typename ValueT, typename KeyInfoT> class DenseMapBase {
  protected:   typedef std::pair<KeyT, ValueT> BucketT;
  public:   typedef KeyT key_type;
   typedef BucketT value_type;
   typedef DenseMapIterator<KeyT, ValueT, KeyInfoT> iterator;
   void clear() {     if (getNumEntries() == 0 && getNumTombstones() == 0) return;     if (getNumEntries() * 4 < getNumBuckets() && getNumBuckets() > 64) {       shrink_and_clear();       return;     }     const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();     for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) {       if (!KeyInfoT::isEqual(P->first, EmptyKey)) {         if (!KeyInfoT::isEqual(P->first, TombstoneKey)) {           P->second.~ValueT();           decrementNumEntries();         }         P->first = EmptyKey;       }     }     (void)((!!(getNumEntries() == 0 && "Node count imbalance!")) ||            (_wassert(L"getNumEntries() == 0 && \"Node count imbalance!\"",                      L"..\\include\\llvm/ADT/DenseMap.h", 98),             0));     setNumTombstones(0);   }
   bool count(const KeyT &Val) const {     const BucketT *TheBucket;     return LookupBucketFor(Val, TheBucket);   }
   ValueT lookup(const KeyT &Val) const {     const BucketT *TheBucket;     if (LookupBucketFor(Val, TheBucket)) return TheBucket->second;     return ValueT();   }
   std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {     BucketT *TheBucket;     if (LookupBucketFor(KV.first, TheBucket))       return std::make_pair(iterator(TheBucket, getBucketsEnd(), true), false);     TheBucket = InsertIntoBucket(KV.first, KV.second, TheBucket);     return std::make_pair(iterator(TheBucket, getBucketsEnd(), true), true);   }
   value_type &FindAndConstruct(const KeyT &Key) {     BucketT *TheBucket;     if (LookupBucketFor(Key, TheBucket)) return *TheBucket;     return *InsertIntoBucket(Key, ValueT(), TheBucket);   }
   ValueT &operator[](const KeyT &Key) { return FindAndConstruct(Key).second; }
  protected:   DenseMapBase() {}
   void destroyAll() {     if (getNumBuckets() == 0) return;     const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();     for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) {       if (!KeyInfoT::isEqual(P->first, EmptyKey) &&           !KeyInfoT::isEqual(P->first, TombstoneKey))         P->second.~ValueT();       P->first.~KeyT();     }     memset((void *)getBuckets(), 0x5a, sizeof(BucketT) * getNumBuckets());   }
   void initEmpty() {     setNumEntries(0);     setNumTombstones(0);     (void)((!!((getNumBuckets() & (getNumBuckets() - 1)) == 0 &&                "# initial buckets must be a power of two!")) ||            (_wassert(L"(getNumBuckets() & (getNumBuckets()-1)) == 0 && \"# "                      L"initial buckets must be a power of two!\"",                      L"..\\include\\llvm/ADT/DenseMap.h", 272),             0));     const KeyT EmptyKey = getEmptyKey();     for (BucketT *B = getBuckets(), *E = getBucketsEnd(); B != E; ++B)       new (&B->first) KeyT(EmptyKey);   }
   template <typename LookupKeyT>   static unsigned getHashValue(const LookupKeyT &Val) {     return KeyInfoT::getHashValue(Val);   }
   static const KeyT getEmptyKey() { return KeyInfoT::getEmptyKey(); }
   static const KeyT getTombstoneKey() { return KeyInfoT::getTombstoneKey(); }
  private:   unsigned getNumEntries() const {     return static_cast<const DerivedT *>(this)->getNumEntries();   }
   void setNumEntries(unsigned Num) {     static_cast<DerivedT *>(this)->setNumEntries(Num);   }
   void incrementNumEntries() { setNumEntries(getNumEntries() + 1); }
   void decrementNumEntries() { setNumEntries(getNumEntries() - 1); }
   unsigned getNumTombstones() const {     return static_cast<const DerivedT *>(this)->getNumTombstones();   }
   void setNumTombstones(unsigned Num) {     static_cast<DerivedT *>(this)->setNumTombstones(Num);   }
   void incrementNumTombstones() { setNumTombstones(getNumTombstones() + 1); }
   void decrementNumTombstones() { setNumTombstones(getNumTombstones() - 1); }
   const BucketT *getBuckets() const {     return static_cast<const DerivedT *>(this)->getBuckets();   }
   BucketT *getBuckets() { return static_cast<DerivedT *>(this)->getBuckets(); }
   unsigned getNumBuckets() const {     return static_cast<const DerivedT *>(this)->getNumBuckets();   }
   BucketT *getBucketsEnd() { return getBuckets() + getNumBuckets(); }
   const BucketT *getBucketsEnd() const {     return getBuckets() + getNumBuckets();   }
   void grow(unsigned AtLeast) { static_cast<DerivedT *>(this)->grow(AtLeast); }
   void shrink_and_clear() { static_cast<DerivedT *>(this)->shrink_and_clear(); }
   BucketT *InsertIntoBucket(const KeyT &Key, const ValueT &Value,                             BucketT *TheBucket) {     TheBucket = InsertIntoBucketImpl(Key, TheBucket);     TheBucket->first = Key;     new (&TheBucket->second) ValueT(Value);     return TheBucket;   }
   BucketT *InsertIntoBucket(const KeyT &Key, ValueT &&Value,                             BucketT *TheBucket) {     TheBucket = InsertIntoBucketImpl(Key, TheBucket);     TheBucket->first = Key;     new (&TheBucket->second) ValueT(std::move(Value));     return TheBucket;   }
   BucketT *InsertIntoBucketImpl(const KeyT &Key, BucketT *TheBucket) {     unsigned NewNumEntries = getNumEntries() + 1;     unsigned NumBuckets = getNumBuckets();     if (NewNumEntries * 4 >= NumBuckets * 3) {       this->grow(NumBuckets * 2);       LookupBucketFor(Key, TheBucket);       NumBuckets = getNumBuckets();     }     if (NumBuckets - (NewNumEntries + getNumTombstones()) <= NumBuckets / 8) {       this->grow(NumBuckets * 2);       LookupBucketFor(Key, TheBucket);     }     (void)((!!(TheBucket)) ||            (_wassert(L"TheBucket", L"..\\include\\llvm/ADT/DenseMap.h", 446),             0));     incrementNumEntries();     const KeyT EmptyKey = getEmptyKey();     if (!KeyInfoT::isEqual(TheBucket->first, EmptyKey))       decrementNumTombstones();     return TheBucket;   }
   template <typename LookupKeyT>   bool LookupBucketFor(const LookupKeyT &Val,                        const BucketT *&FoundBucket) const {     const BucketT *BucketsPtr = getBuckets();     const unsigned NumBuckets = getNumBuckets();     if (NumBuckets == 0) {       FoundBucket = 0;       return false;     }     const BucketT *FoundTombstone = 0;     const KeyT EmptyKey = getEmptyKey();     const KeyT TombstoneKey = getTombstoneKey();     (void)((!!(!KeyInfoT::isEqual(Val, EmptyKey) &&                !KeyInfoT::isEqual(Val, TombstoneKey) &&                "Empty/Tombstone value shouldn't be inserted into map!")) ||            (_wassert(L"!KeyInfoT::isEqual(Val, EmptyKey) && "                      L"!KeyInfoT::isEqual(Val, TombstoneKey) && "                      L"\"Empty/Tombstone value shouldn't be inserted into "                      L"map!\"",                      L"..\\include\\llvm/ADT/DenseMap.h", 481),             0));     unsigned BucketNo = getHashValue(Val) & (NumBuckets - 1);     unsigned ProbeAmt = 1;     while (1) {       const BucketT *ThisBucket = BucketsPtr + BucketNo;       if (KeyInfoT::isEqual(Val, ThisBucket->first)) {         FoundBucket = ThisBucket;         return true;       }       if (KeyInfoT::isEqual(ThisBucket->first, EmptyKey)) {         FoundBucket = FoundTombstone ? FoundTombstone : ThisBucket;         return false;       }       if (KeyInfoT::isEqual(ThisBucket->first, TombstoneKey) && !FoundTombstone)         FoundTombstone = ThisBucket;       BucketNo += ProbeAmt++;       BucketNo &= (NumBuckets - 1);     }   }
   template <typename LookupKeyT>   bool LookupBucketFor(const LookupKeyT &Val, BucketT *&FoundBucket) {     const BucketT *ConstFoundBucket;     bool Result = const_cast<const DenseMapBase *>(this)                       ->LookupBucketFor(Val, ConstFoundBucket);     FoundBucket = const_cast<BucketT *>(ConstFoundBucket);     return Result;   }
  public:   size_t getMemorySize() const { return getNumBuckets() * sizeof(BucketT); }
 };
    template <typename KeyT, typename ValueT,           typename KeyInfoT = DenseMapInfo<KeyT> > class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT>, KeyT,                                      ValueT, KeyInfoT> {
   typedef DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT> BaseT;
   typedef typename BaseT::BucketT BucketT;
   BucketT *Buckets;
   unsigned NumEntries;
   unsigned NumTombstones;
   unsigned NumBuckets;
  public:   explicit DenseMap(unsigned NumInitBuckets = 0) { init(NumInitBuckets); }
   ~DenseMap() {     this->destroyAll();     operator delete(Buckets);   }
   void copyFrom(const DenseMap &other) {     this->destroyAll();     operator delete(Buckets);     if (allocateBuckets(other.NumBuckets)) {       this->BaseT::copyFrom(other);     } else {       NumEntries = 0;       NumTombstones = 0;     }   }
   void init(unsigned InitBuckets) {     if (allocateBuckets(InitBuckets)) {       this->BaseT::initEmpty();     } else {       NumEntries = 0;       NumTombstones = 0;     }   }
   bool allocateBuckets(unsigned Num) {     NumBuckets = Num;     if (NumBuckets == 0) {       Buckets = 0;       return false;     }     Buckets =         static_cast<BucketT *>(operator new(sizeof(BucketT) * NumBuckets));     return true;   }
 };
    template <typename KeyT, typename ValueT, unsigned InlineBuckets = 4,           typename KeyInfoT = DenseMapInfo<KeyT> > class SmallDenseMap     : public DenseMapBase<SmallDenseMap<KeyT, ValueT, InlineBuckets, KeyInfoT>,                           KeyT, ValueT, KeyInfoT> {
 };
    template <typename KeyT, typename ValueT, typename KeyInfoT> static inline size_t capacity_in_bytes(     const DenseMap<KeyT, ValueT, KeyInfoT> &X) {
   return X.getMemorySize();
 }
    template <typename PointerTy, unsigned IntBits, typename IntType = unsigned,           typename PtrTraits = PointerLikeTypeTraits<PointerTy> > class PointerIntPair {
   intptr_t Value;
   enum : uintptr_t {     PointerBitMask =         ~(uintptr_t)(((intptr_t)1 << PtrTraits::NumLowBitsAvailable) - 1),     IntShift = (uintptr_t)PtrTraits::NumLowBitsAvailable - IntBits,     IntMask = (uintptr_t)(((intptr_t)1 << IntBits) - 1),     ShiftedIntMask = (uintptr_t)(IntMask << IntShift)   };
  public:   PointerIntPair() : Value(0) {}
   PointerIntPair(PointerTy PtrVal, IntType IntVal) {     (void)((!!(IntBits <= PtrTraits::NumLowBitsAvailable &&                "PointerIntPair formed with integer size too large for "                "pointer")) ||            (_wassert(L"IntBits <= PtrTraits::NumLowBitsAvailable && "                      L"\"PointerIntPair formed with integer size too large for "                      L"pointer\"",                      L"..\\include\\llvm/ADT/PointerIntPair.h", 63),             0));     setPointerAndInt(PtrVal, IntVal);   }
   PointerTy getPointer() const {     return PtrTraits::getFromVoidPointer(         reinterpret_cast<void *>(Value & PointerBitMask));   }
   IntType getInt() const { return (IntType)((Value >> IntShift) & IntMask); }
   void setPointer(PointerTy PtrVal) {     intptr_t PtrWord =         reinterpret_cast<intptr_t>(PtrTraits::getAsVoidPointer(PtrVal));     (void)((!!((PtrWord & ((1 << PtrTraits::NumLowBitsAvailable) - 1)) == 0 &&                "Pointer is not sufficiently aligned")) ||            (_wassert(L"(PtrWord & ((1 << PtrTraits::NumLowBitsAvailable)-1)) "                      L"== 0 && \"Pointer is not sufficiently aligned\"",                      L"..\\include\\llvm/ADT/PointerIntPair.h", 83),             0));     Value = PtrWord | (Value & ~PointerBitMask);   }
   void setInt(IntType IntVal) {     intptr_t IntWord = static_cast<intptr_t>(IntVal);     (void)((!!(IntWord < (1 << IntBits) && "Integer too large for field")) ||            (_wassert(                 L"IntWord < (1 << IntBits) && \"Integer too large for field\"",                 L"..\\include\\llvm/ADT/PointerIntPair.h", 90),             0));     Value &= ~ShiftedIntMask;     Value |= IntWord << IntShift;   }
   void initWithPointer(PointerTy PtrVal) {     intptr_t PtrWord =         reinterpret_cast<intptr_t>(PtrTraits::getAsVoidPointer(PtrVal));     (void)((!!((PtrWord & ((1 << PtrTraits::NumLowBitsAvailable) - 1)) == 0 &&                "Pointer is not sufficiently aligned")) ||            (_wassert(L"(PtrWord & ((1 << PtrTraits::NumLowBitsAvailable)-1)) "                      L"== 0 && \"Pointer is not sufficiently aligned\"",                      L"..\\include\\llvm/ADT/PointerIntPair.h", 101),             0));     Value = PtrWord;   }
   void setPointerAndInt(PointerTy PtrVal, IntType IntVal) {     intptr_t PtrWord =         reinterpret_cast<intptr_t>(PtrTraits::getAsVoidPointer(PtrVal));     (void)((!!((PtrWord & ((1 << PtrTraits::NumLowBitsAvailable) - 1)) == 0 &&                "Pointer is not sufficiently aligned")) ||            (_wassert(L"(PtrWord & ((1 << PtrTraits::NumLowBitsAvailable)-1)) "                      L"== 0 && \"Pointer is not sufficiently aligned\"",                      L"..\\include\\llvm/ADT/PointerIntPair.h", 109),             0));     intptr_t IntWord = static_cast<intptr_t>(IntVal);     (void)((!!(IntWord < (1 << IntBits) && "Integer too large for field")) ||            (_wassert(                 L"IntWord < (1 << IntBits) && \"Integer too large for field\"",                 L"..\\include\\llvm/ADT/PointerIntPair.h", 111),             0));     Value = PtrWord | (IntWord << IntShift);   }
 };
    template <typename T> struct isPodLike;
    }
    namespace llvm {
    enum NoneType {
   None };
    class SmallVectorBase {
  protected:   void *BeginX, *EndX, *CapacityX;
  protected:   SmallVectorBase(void *FirstEl, size_t Size)       : BeginX(FirstEl), EndX(FirstEl), CapacityX((char *)FirstEl + Size) {}
   void grow_pod(void *FirstEl, size_t MinSizeInBytes, size_t TSize);
 };
    template <typename T, unsigned N> struct SmallVectorStorage;
    template <typename T, typename = void> class SmallVectorTemplateCommon : public SmallVectorBase {
  private:   template <typename, unsigned>   friend struct SmallVectorStorage;
   typedef llvm::AlignedCharArrayUnion<T> U;
   U FirstEl;
  protected:   SmallVectorTemplateCommon(size_t Size) : SmallVectorBase(&FirstEl, Size) {}
   void grow_pod(size_t MinSizeInBytes, size_t TSize) {     SmallVectorBase::grow_pod(&FirstEl, MinSizeInBytes, TSize);   }
   void setEnd(T *P) { this->EndX = P; }
  public:   typedef size_t size_type;
   typedef T value_type;
   typedef T *iterator;
   typedef const T *const_iterator;
   typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
   typedef std::reverse_iterator<iterator> reverse_iterator;
   typedef T &reference;
   typedef const T &const_reference;
   typedef T *pointer;
   iterator begin() { return (iterator) this->BeginX; }
   const_iterator begin() const { return (const_iterator) this->BeginX; }
   iterator end() { return (iterator) this->EndX; }
   const_iterator end() const { return (const_iterator) this->EndX; }
  protected:   iterator capacity_ptr() { return (iterator) this->CapacityX; }
  public:   reverse_iterator rbegin() { return reverse_iterator(end()); }
   const_reverse_iterator rbegin() const {     return const_reverse_iterator(end());   }
   const_reverse_iterator rend() const {     return const_reverse_iterator(begin());   }
   size_type size() const { return end() - begin(); }
   const_reference operator[](unsigned idx) const {     (void)((!!(begin() + idx < end())) ||            (_wassert(L"begin() + idx < end()",                      L"..\\include\\llvm/ADT/SmallVector.h", 144),             0));     return begin()[idx];   }
   reference front() {     (void)((!!(!empty())) ||            (_wassert(L"!empty()", L"..\\include\\llvm/ADT/SmallVector.h", 149),             0));     return begin()[0];   }
 };
    template <typename T, bool isPodLike> class SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
  protected:   SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}
   template <typename It1, typename It2>   static void uninitialized_copy(It1 I, It1 E, It2 Dest) {     std::uninitialized_copy(I, E, Dest);   }
   void grow(size_t MinSize = 0);
 };
    template <typename T, bool isPodLike> void SmallVectorTemplateBase<T, isPodLike>::grow(size_t MinSize) {
   size_t CurCapacity = this->capacity();
 }
    template <typename T> class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
  protected:   SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}
   void grow(size_t MinSize = 0) {     this->grow_pod(MinSize * sizeof(T), sizeof(T));   }
  public:   void push_back(const T &Elt) {     if (this->EndX < this->CapacityX) {     Retry:       memcpy(this->end(), &Elt, sizeof(T));       this->setEnd(this->end() + 1);       return;     }     this->grow();     goto Retry;   }
 };
    template <typename T> class SmallVectorImpl : public SmallVectorTemplateBase<T, isPodLike<T>::value> {
  protected:   explicit SmallVectorImpl(unsigned N)       : SmallVectorTemplateBase<T, isPodLike<T>::value>(N * sizeof(T)) {}
   void swap(SmallVectorImpl &RHS);
   template <typename in_iter>   void append(in_iter in_start, in_iter in_end) {     size_type NumInputs = std::distance(in_start, in_end);     if (NumInputs > size_type(this->capacity_ptr() - this->end()))       this->grow(this->size() + NumInputs);     std::uninitialized_copy(in_start, in_end, this->end());     this->setEnd(this->end() + NumInputs);   }
   void set_size(unsigned N) {     (void)((!!(N <= this->capacity())) ||            (_wassert(L"N <= this->capacity()",                      L"..\\include\\llvm/ADT/SmallVector.h", 703),             0));     this->setEnd(this->begin() + N);   }
 };
    template <typename T> void SmallVectorImpl<T>::swap(SmallVectorImpl<T> &RHS) {
   if (this == &RHS) return;
 }
    template <typename T, unsigned N> struct SmallVectorStorage {
   typename SmallVectorTemplateCommon<T>::U InlineElts[N - 1];
 };
    template <typename T> struct SmallVectorStorage<T, 0> {
};
    template <typename T, unsigned N> class SmallVector : public SmallVectorImpl<T> {
   SmallVectorStorage<T, N> Storage;
  public:   SmallVector() : SmallVectorImpl<T>(N) {}
 };
    template <typename T, unsigned N> static inline size_t capacity_in_bytes(const SmallVector<T, N> &X) {
 }
    }
    namespace std {
    template <class _Myvec> class _Vector_const_iterator : public _Iterator012<     random_access_iterator_tag, typename _Myvec::value_type,     typename _Myvec::difference_type, typename _Myvec::const_pointer,     typename _Myvec::const_reference, _Iterator_base> {
  public:   typedef _Vector_const_iterator<_Myvec> _Myiter;
   typedef typename _Myvec::value_type value_type;
   typedef typename _Myvec::difference_type difference_type;
   typedef typename _Myvec::const_pointer pointer;
   typedef typename _Myvec::const_reference reference;
   typedef typename _Myvec::pointer _Tptr;
   _Vector_const_iterator(_Tptr _Parg, const _Container_base *_Pvector)       : _Ptr(_Parg) {     this->_Adopt(_Pvector);   }
   typedef pointer _Unchecked_type;
   _Unchecked_type _Unchecked() const { return (_Unchecked_type(this->_Ptr)); }
   reference operator*() const {     ;     return (*this->_Ptr);   }
   _Myiter &operator++() {     ++this->_Ptr;     return (*this);   }
   _Myiter operator++(int) {     _Myiter _Tmp = *this;     ++*this;     return (_Tmp);   }
   reference operator[](difference_type _Off) const { return (*(*this + _Off)); }
   bool operator==(const _Myiter &_Right) const {     _Compat(_Right);     return (this->_Ptr == _Right._Ptr);   }
   bool operator!=(const _Myiter &_Right) const { return (!(*this == _Right)); }
   bool operator>=(const _Myiter &_Right) const { return (!(*this < _Right)); }
   void _Compat(const _Myiter &) const {}
   _Tptr _Ptr;
 };
    template <class _Myvec> inline typename _Vector_const_iterator<_Myvec>::_Unchecked_type _Unchecked(     _Vector_const_iterator<_Myvec> _Iter) {
 }
    template <class _Myvec> class _Vector_iterator : public _Vector_const_iterator<_Myvec> {
  public:   typedef _Vector_iterator<_Myvec> _Myiter;
   typedef _Vector_const_iterator<_Myvec> _Mybase;
   typedef typename _Myvec::pointer pointer;
   typedef typename _Myvec::reference reference;
   _Vector_iterator(pointer _Parg, const _Container_base *_Pvector)       : _Mybase(_Parg, _Pvector) {}
   typedef pointer _Unchecked_type;
 };
    template <class _Myvec> inline typename _Vector_iterator<_Myvec>::_Unchecked_type _Unchecked(     _Vector_iterator<_Myvec> _Iter) {
 }
    template <class _Value_type, class _Size_type, class _Difference_type,           class _Pointer, class _Const_pointer, class _Reference,           class _Const_reference> struct _Vec_iter_types {
   typedef _Const_reference const_reference;
 };
    template <class _Ty, class _Alloc0> struct _Vec_base_types {
   typedef _Alloc0 _Alloc;
   typedef _Wrap_alloc<_Alloc> _Alty0;
   typedef typename _Alty0::template rebind<_Ty>::other _Alty;
   typedef typename _Alty::pointer _Tptr;
   typedef typename _Alty::template rebind<_Tptr>::other _Alpty;
   typedef typename _If<       _Is_simple_alloc<_Alty>::value, _Simple_types<typename _Alty::value_type>,       _Vec_iter_types<typename _Alty::value_type, typename _Alty::size_type,                       typename _Alty::difference_type, typename _Alty::pointer,                       typename _Alty::const_pointer, typename _Alty::reference,                       typename _Alty::const_reference> >::type _Val_types;
 };
    template <class _Val_types> class _Vector_val : public _Container_base {
  public:   typedef _Vector_val<_Val_types> _Myt;
   typedef typename _Val_types::value_type value_type;
   typedef typename _Val_types::size_type size_type;
   typedef typename _Val_types::difference_type difference_type;
   typedef typename _Val_types::pointer pointer;
   typedef typename _Val_types::const_pointer const_pointer;
   typedef typename _Val_types::reference reference;
   typedef typename _Val_types::const_reference const_reference;
   typedef _Vector_iterator<_Myt> iterator;
   typedef _Vector_const_iterator<_Myt> const_iterator;
   pointer _Myfirst;
   pointer _Mylast;
   pointer _Myend;
 };
    template <bool _Al_has_storage, class _Alloc_types> class _Vector_alloc : public _Vector_val<typename _Alloc_types::_Val_types> {
 };
    template <class _Alloc_types> class _Vector_alloc<false, _Alloc_types> : public _Vector_val<     typename _Alloc_types::_Val_types> {
  public:   typedef _Vector_alloc<false, _Alloc_types> _Myt;
   typedef typename _Alloc_types::_Alloc _Alloc;
   typedef typename _Alloc_types::_Alty _Alty;
   _Vector_alloc(const _Alloc & = _Alloc()) {}
   void _Swap_alloc(_Myt &) {}
   _Alty _Getal() const { return (_Alty()); }
 };
    template <class _Ty, class _Alloc = allocator<_Ty> > class vector : public _Vector_alloc<!is_empty<_Alloc>::value,                                     _Vec_base_types<_Ty, _Alloc> > {
  public:   typedef vector<_Ty, _Alloc> _Myt;
   typedef _Vector_alloc<!is_empty<_Alloc>::value, _Vec_base_types<_Ty, _Alloc> >       _Mybase;
   typedef _Alloc allocator_type;
   typedef typename _Mybase::_Alty _Alty;
   typedef typename _Mybase::value_type value_type;
   typedef typename _Mybase::size_type size_type;
   typedef typename _Mybase::difference_type difference_type;
   typedef typename _Mybase::pointer pointer;
   typedef typename _Mybase::reference reference;
   typedef typename _Mybase::const_reference const_reference;
   typedef typename _Mybase::iterator iterator;
   typedef typename _Mybase::const_iterator const_iterator;
   typedef ::std::reverse_iterator<iterator> reverse_iterator;
   _Myt &operator=(const _Myt &_Right) {     if (this != &_Right) {       if (this->_Getal() != _Right._Getal() &&           _Alty::propagate_on_container_copy_assignment::value) {         _Tidy();         this->_Change_alloc(_Right._Getal());       }       this->_Orphan_all();       if (_Right.empty())         clear();       else if (_Right.size() <= size()) {         pointer _Ptr =             _Copy_impl(_Right._Myfirst, _Right._Mylast, this->_Myfirst);         _Destroy(_Ptr, this->_Mylast);         this->_Mylast = this->_Myfirst + _Right.size();       } else if (_Right.size() <= capacity()) {         pointer _Ptr = _Right._Myfirst + size();         _Copy_impl(_Right._Myfirst, _Ptr, this->_Myfirst);         this->_Mylast = _Ucopy(_Ptr, _Right._Mylast, this->_Mylast);       } else {         if (this->_Myfirst != pointer()) {           _Destroy(this->_Myfirst, this->_Mylast);           this->_Getal().deallocate(this->_Myfirst,                                     this->_Myend - this->_Myfirst);         }         if (_Buy(_Right.size())) {           {             this->_Mylast =                 _Ucopy(_Right._Myfirst, _Right._Mylast, this->_Myfirst);           }           if (0) {             _Tidy();             ;           }         }       }     }     return (*this);   }
   void reserve(size_type _Count) {     if (capacity() < _Count) {       if (max_size() < _Count) _Xlen();       _Reallocate(_Count);     }   }
   size_type capacity() const throw() { return (this->_Myend - this->_Myfirst); }
   const_iterator begin() const throw() {     return (const_iterator(this->_Myfirst, this));   }
   iterator end() throw() { return (iterator(this->_Mylast, this)); }
   const_iterator end() const throw() {     return (const_iterator(this->_Mylast, this));   }
   size_type size() const throw() { return (this->_Mylast - this->_Myfirst); }
   size_type max_size() const throw() { return (this->_Getal().max_size()); }
   bool empty() const throw() { return (this->_Myfirst == this->_Mylast); }
   _Alloc get_allocator() const throw() { return (this->_Getal()); }
   const_reference operator[](size_type _Pos) const {     return (*(this->_Myfirst + _Pos));   }
   reference front() { return (*begin()); }
   const_reference front() const { return (*begin()); }
   void clear() throw() {     this->_Orphan_all();     _Destroy(this->_Myfirst, this->_Mylast);     this->_Mylast = this->_Myfirst;   }
   void swap(_Myt &_Right) {     if (this == &_Right)       ;     else if (this->_Getal() == _Right._Getal()) {       this->_Swap_all(_Right);       _Swap_adl(this->_Myfirst, _Right._Myfirst);       _Swap_adl(this->_Mylast, _Right._Mylast);       _Swap_adl(this->_Myend, _Right._Myend);     } else if (_Alty::propagate_on_container_swap::value) {       this->_Swap_alloc(_Right);       _Swap_adl(this->_Myfirst, _Right._Myfirst);       _Swap_adl(this->_Mylast, _Right._Mylast);       _Swap_adl(this->_Myend, _Right._Myend);     } else {       _Myt _Ts = _Move(*this);       *this = _Move(_Right);       _Right = _Move(_Ts);     }   }
   bool _Buy(size_type _Capacity) {     this->_Myfirst = pointer();     this->_Mylast = pointer();     this->_Myend = pointer();     if (_Capacity == 0)       return (false);     else if (max_size() < _Capacity)       _Xlen();     else {       this->_Myfirst = this->_Getal().allocate(_Capacity);       this->_Mylast = this->_Myfirst;       this->_Myend = this->_Myfirst + _Capacity;     }     return (true);   }
   void _Destroy(pointer _First, pointer _Last) {     _Alty _Alval(this->_Getal());     _Destroy_range(_First, _Last, _Alval);   }
   bool _Inside(const value_type *_Ptr) const {     return (_Ptr < this->_Mylast && this->_Myfirst <= _Ptr);   }
   void _Reallocate(size_type _Count) {     pointer _Ptr = this->_Getal().allocate(_Count);     {       { _Umove(this->_Myfirst, this->_Mylast, _Ptr); }       if (0) {         this->_Getal().deallocate(_Ptr, _Count);         ;       }     }     size_type _Size = size();     if (this->_Myfirst != pointer()) {       _Destroy(this->_Myfirst, this->_Mylast);       this->_Getal().deallocate(this->_Myfirst, this->_Myend - this->_Myfirst);     }     this->_Orphan_all();     this->_Myend = _Ptr + _Count;     this->_Mylast = _Ptr + _Size;     this->_Myfirst = _Ptr;   }
   template <class _Iter>   pointer _Umove(_Iter _First, _Iter _Last, pointer _Ptr) {     _Alty _Alval(this->_Getal());     return (_Uninitialized_move(_First, _Last, _Ptr, _Alval));   }
   __declspec(noreturn) void _Xlen() const {     _Xlength_error("vector<T> too long");   }
 };
    template <class _Ty, class _Alloc> inline void swap(vector<_Ty, _Alloc> &_Left, vector<_Ty, _Alloc> &_Right) {
   _Left.swap(_Right);
   return (lexicographical_compare(_Left.begin(), _Left.end(), _Right.begin(),                                   _Right.end()));
 }
    typedef unsigned int _Vbase;
    const int _VBITS = 8 * sizeof(_Vbase);
    template <class _Alloc> class _Vb_iter_base : public _Iterator012<random_access_iterator_tag, _Bool,                                           typename _Alloc::difference_type,                                           bool *, bool, _Iterator_base> {
 };
    template <class _Alloc> class _Vb_reference : public _Vb_iter_base<_Alloc> {
 };
    template <class _Alloc> inline void swap(_Vb_reference<_Alloc> _Left, _Vb_reference<_Alloc> _Right) {
   bool _Val = _Left;
   _Right = _Val;
 }
    template <class _Alloc> class _Vb_const_iterator : public _Vb_iter_base<_Alloc> {
 };
    template <class _Alloc> inline _Vb_const_iterator<_Alloc> operator+(     typename _Alloc::difference_type _Off, _Vb_const_iterator<_Alloc> _Right) {
   return (_Right += _Off);
 }
    template <class _Alloc> class _Vb_iterator : public _Vb_const_iterator<_Alloc> {
 };
    template <class _Alloc> inline bool operator==(const vector<bool, _Alloc> &_Left,                        const vector<bool, _Alloc> &_Right) {
   return (       _Left.size() == _Right.size() &&       equal(_Left._Myvec.begin(), _Left._Myvec.end(), _Right._Myvec.begin()));
 };
    }
    namespace llvm {
    template <typename T> class ArrayRef {
  public:   typedef const T *iterator;
   typedef size_t size_type;
   typedef std::reverse_iterator<iterator> reverse_iterator;
   size_type Length;
  public:   ArrayRef() : Data(0), Length(0) {}
   size_t size() const { return Length; }
 };
    }
    namespace std {
    template <class _Elem, class _Traits, class _Alloc> inline basic_string<_Elem, _Traits, _Alloc> operator+(     const basic_string<_Elem, _Traits, _Alloc> &_Left,     const basic_string<_Elem, _Traits, _Alloc> &_Right) {
   size_t operator()(const _Kty &_Keyval) const {     return (_Hash_seq((const unsigned char *)_Keyval.c_str(),                       _Keyval.size() * sizeof(_Elem)));   }
 };
    }
    namespace llvm {
    template <typename T> class SmallVectorImpl;
    class APInt;
    class hash_code;
    class StringRef {
  public:   typedef const char *iterator;
  private:   const char *Data;
   size_t Length;
   static size_t min(size_t a, size_t b) { return a < b ? a : b; }
   static int compareMemory(const char *Lhs, const char *Rhs, size_t Length) {     if (Length == 0) {       return 0;     }     return ::memcmp(Lhs, Rhs, Length);   }
  public:   StringRef() : Data(0), Length(0) {}
   StringRef(const char *Str) : Data(Str) {     (void)((!!(Str && "StringRef cannot be built from a NULL argument")) ||            (_wassert(                 L"Str && \"StringRef cannot be built from a NULL argument\"",                 L"..\\include\\llvm/ADT/StringRef.h", 78),             0));     Length = ::strlen(Str);   }
   bool empty() const { return Length == 0; }
   char back() const {     (void)((!!(!empty())) ||            (_wassert(L"!empty()", L"..\\include\\llvm/ADT/StringRef.h", 123),             0));     return Data[Length - 1];   }
   bool equals(StringRef RHS) const {     return (Length == RHS.Length &&             compareMemory(Data, RHS.Data, RHS.Length) == 0);   }
   bool equals_lower(StringRef RHS) const {     return Length == RHS.Length && compare_lower(RHS) == 0;   }
   int compare(StringRef RHS) const {     if (int Res = compareMemory(Data, RHS.Data, min(Length, RHS.Length)))       return Res < 0 ? -1 : 1;     if (Length == RHS.Length) return 0;     return Length < RHS.Length ? -1 : 1;   }
   int compare_lower(StringRef RHS) const;
   std::string str() const {     if (Data == 0) return std::string();     return std::string(Data, Length);   }
   char operator[](size_t Index) const {     (void)((!!(Index < Length && "Invalid index!")) ||            (_wassert(L"Index < Length && \"Invalid index!\"",                      L"..\\include\\llvm/ADT/StringRef.h", 191),             0));     return Data[Index];   }
   operator std::string() const { return str(); }
 };
    inline bool operator==(StringRef LHS, StringRef RHS) {
 return LHS.equals(RHS);
   return LHS.compare(RHS) == 1;
 }
    template <typename T> struct isPodLike;
    template <> struct isPodLike<StringRef> {
 };
    inline StringRef toStringRef(bool B) {
 }
    }
    namespace llvm {
    class FoldingSetNodeID;
    class FoldingSetImpl {
   unsigned NumNodes;
  public:   explicit FoldingSetImpl(unsigned Log2InitSize = 6);
   class Node {    private:     void *NextInFoldingSetBucket;    public:     Node() : NextInFoldingSetBucket(0) {}     void *getNextInBucket() const { return NextInFoldingSetBucket; }     void SetNextInBucket(void *N) { NextInFoldingSetBucket = N; }   };
   void clear();
   virtual unsigned ComputeNodeHash(Node *N, FoldingSetNodeID &TempID) const = 0;
 };
    template <typename T> struct FoldingSetTrait;
    template <typename T> struct DefaultFoldingSetTrait {
   static void Profile(const T &X, FoldingSetNodeID &ID) { X.Profile(ID); }
   static inline bool Equals(T &X, const FoldingSetNodeID &ID, unsigned IDHash,                             FoldingSetNodeID &TempID);
   static inline unsigned ComputeHash(T &X, FoldingSetNodeID &TempID);
};
    template <typename T, typename Ctx> struct ContextualFoldingSetTrait;
    template <typename T, typename Ctx> struct DefaultContextualFoldingSetTrait {
};
    class FoldingSetNodeIDRef {
   const unsigned *Data;
   size_t Size;
   size_t getSize() const { return Size; }
 };
    class FoldingSetNodeID {
   SmallVector<unsigned, 32> Bits;
  public:   FoldingSetNodeID() {}
   void AddPointer(const void *Ptr);
   void AddInteger(signed I);
 };
    typedef FoldingSetImpl::Node FoldingSetNode;
    template <class T> class FoldingSetBucketIterator;
    template <typename T> inline bool DefaultFoldingSetTrait<T>::Equals(T &X, const FoldingSetNodeID &ID,                                               unsigned,                                               FoldingSetNodeID &TempID) {
  public:   void Profile(FoldingSetNodeID &ID) const { ID.AddNodeID(FastID); }
 };
    }
    namespace std {
    template <size_t _Bits> class bitset {
  public:   enum : size_t {     _EEN_BITS = _Bits   };
 };
    template <size_t _Bits> inline bitset<_Bits> operator&(const bitset<_Bits> &_Left,                                const bitset<_Bits> &_Right) throw() {
   return (_Ans &= _Right);
 }
    template <size_t _Bits> inline bitset<_Bits> operator|(const bitset<_Bits> &_Left,                                const bitset<_Bits> &_Right) throw() {
 };
    template <class _Mytree, class _Base = _Iterator_base0> class _Tree_unchecked_const_iterator : public _Iterator012<     bidirectional_iterator_tag, typename _Mytree::value_type,     typename _Mytree::difference_type, typename _Mytree::const_pointer,     typename _Mytree::const_reference, _Base> {
 };
    template <class _Mytree> class _Tree_const_iterator     : public _Tree_unchecked_const_iterator<_Mytree, _Iterator_base> {
  public:   typedef _Tree_const_iterator<_Mytree> _Myiter;
   bool operator!=(const _Myiter &_Right) const { return (!(*this == _Right)); }
 };
    template <class _Mytree> class _Tree_iterator : public _Tree_const_iterator<_Mytree> {
  public:   typedef _Tree_iterator<_Mytree> _Myiter;
   typedef _Tree_const_iterator<_Mytree> _Mybase;
   _Myiter operator--(int) {     _Myiter _Tmp = *this;     --*this;     return (_Tmp);   }
 };
    template <class _Mytree> inline _Tree_iterator<_Mytree> &_Rechecked(     _Tree_iterator<_Mytree> &_Iter,     typename _Tree_iterator<_Mytree>::_Unchecked_type _Right) {
   return (_Iter._Rechecked(_Right));
   typedef _Nodeptr_type _Nodeptr;
 };
    template <class _Value_type, class _Voidptr> struct _Tree_node {
  private:   _Tree_node &operator=(const _Tree_node &);
 };
    template <class _Value_type> struct _Tree_node<_Value_type, void *> {
  private:   _Tree_node &operator=(const _Tree_node &);
 };
    template <class _Ty> struct _Tree_simple_types : public _Simple_types<_Ty> {
 };
    template <class _Ty, class _Alloc0> struct _Tree_base_types {
   typedef _Alloc0 _Alloc;
 };
    template <class _Val_types> class _Tree_val : public _Container_base {
  public:   typedef _Tree_val<_Val_types> _Myt;
 };
    template <bool _Al_has_storage, class _Alloc_types> class _Tree_alloc : public _Tree_val<typename _Alloc_types::_Val_types> {
 };
    template <class _Ty, class _Alloc> class _Tree_buy : public _Tree_alloc<!is_empty<_Alloc>::value,                                      _Tree_base_types<_Ty, _Alloc> > {
  public:   typedef _Tree_alloc<!is_empty<_Alloc>::value, _Tree_base_types<_Ty, _Alloc> >       _Mybase;
   typedef typename _Mybase::_Alty _Alty;
   typedef typename _Mybase::_Nodeptr _Nodeptr;
   template <class _V0_t, class _V1_t, class _V2_t, class _V3_t, class _V4_t,             class _V5_t, class _V6_t, class _V7_t, class _V8_t, class _V9_t>   _Nodeptr _Buynode(_V0_t &&_V0, _V1_t &&_V1, _V2_t &&_V2, _V3_t &&_V3,                     _V4_t &&_V4, _V5_t &&_V5, _V6_t &&_V6, _V7_t &&_V7,                     _V8_t &&_V8, _V9_t &&_V9) {     _Nodeptr _Pnode = _Buynode0();     this->_Color(_Pnode) = this->_Red;     this->_Isnil(_Pnode) = false;     {       {         this->_Getal().construct(             ::std::addressof(this->_Myval(_Pnode)), ::std::forward<_V0_t>(_V0),             ::std::forward<_V1_t>(_V1), ::std::forward<_V2_t>(_V2),             ::std::forward<_V3_t>(_V3), ::std::forward<_V4_t>(_V4),             ::std::forward<_V5_t>(_V5), ::std::forward<_V6_t>(_V6),             ::std::forward<_V7_t>(_V7), ::std::forward<_V8_t>(_V8),             ::std::forward<_V9_t>(_V9));       }       if (0) {         _Freenode0(_Pnode);         ;       }     }     return (_Pnode);   }
 };
    template <bool _Pr_has_storage, class _Traits> class _Tree_comp : public _Tree_buy<typename _Traits::value_type,                                     typename _Traits::allocator_type> {
   typedef typename _Traits::key_compare key_compare;
   void _Swapcomp(const key_compare &) {}
 };
    template <class _Traits> class _Tree : public _Tree_comp<!is_empty<typename _Traits::key_compare>::value,                                 _Traits> {
 };
    template <class _Traits> inline bool operator==(const _Tree<_Traits> &_Left,                        const _Tree<_Traits> &_Right) {
   return (!(_Left < _Right));
 }
    template <class _Kty, class _Ty, class _Pr, class _Alloc, bool _Mfl> class _Tmap_traits {
   template <class _Ty1, class _Ty2>   static const _Kty &_Kfn(const pair<_Ty1, _Ty2> &_Val) {     return (_Val.first);   }
 };
    template <class _Kty, class _Ty, class _Pr = less<_Kty>,           class _Alloc = allocator<pair<const _Kty, _Ty> > > class map : public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false> > {
 };
    template <class _Kty, class _Ty, class _Pr, class _Alloc> inline void swap(map<_Kty, _Ty, _Pr, _Alloc> &_Left,                  map<_Kty, _Ty, _Pr, _Alloc> &_Right) {
 }
    template <class _Kty, class _Ty, class _Pr = less<_Kty>,           class _Alloc = allocator<pair<const _Kty, _Ty> > > class multimap : public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, true> > {
 };
    template <class _Kty, class _Ty, class _Pr, class _Alloc> inline void swap(multimap<_Kty, _Ty, _Pr, _Alloc> &_Left,                  multimap<_Kty, _Ty, _Pr, _Alloc> &_Right) {
   _Left.swap(_Right);
 }
    }
    namespace llvm {
    class AttributeImpl;
    class AttributeSetImpl;
    template <typename T> struct DenseMapInfo;
    class LLVMContext;
    class Attribute {
  public:   enum AttrKind {     None,     Alignment,     AlwaysInline,     Builtin,     ByVal,     Cold,     InlineHint,     InReg,     MinSize,     Naked,     Nest,     NoAlias,     NoBuiltin,     NoCapture,     NoDuplicate,     NoImplicitFloat,     NoInline,     NonLazyBind,     NoRedZone,     NoReturn,     NoUnwind,     OptimizeForSize,     OptimizeNone,     ReadNone,     ReadOnly,     Returned,     ReturnsTwice,     SExt,     StackAlignment,     StackProtect,     StackProtectReq,     StackProtectStrong,     StructRet,     SanitizeAddress,     SanitizeThread,     SanitizeMemory,     UWTable,     ZExt,     EndAttrKinds   };
  private:   AttributeImpl *pImpl;
   void Profile(FoldingSetNodeID &ID) const { ID.AddPointer(pImpl); }
 };
    class AttributeSet {
  public:   enum AttrIndex : unsigned {     ReturnIndex = 0U,     FunctionIndex = ~0U   };
  private:   friend class AttrBuilder;
   template <typename Ty>   friend struct DenseMapInfo;
   AttributeSetImpl *pImpl;
   explicit AttributeSet(AttributeSetImpl *LI) : pImpl(LI) {}
  public:   AttributeSet() : pImpl(0) {}
   bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const;
   void dump() const;
 };
    class AttrBuilder {
   AttrBuilder &addRawValue(uint64_t Val);
 };
    }
    namespace llvm {
    namespace CallingConv {
 }
    }
    namespace llvm {
    template <typename T> class SmallVectorImpl;
    typedef uint64_t integerPart;
    const unsigned int host_char_bit = 8;
    const unsigned int integerPartWidth =     host_char_bit * static_cast<unsigned int>(sizeof(integerPart));
    class APInt {
   unsigned BitWidth;
   union {     uint64_t VAL;     uint64_t *pVal;   };
   enum {     APINT_BITS_PER_WORD = static_cast<unsigned int>(sizeof(uint64_t)) * 8,     APINT_WORD_SIZE = static_cast<unsigned int>(sizeof(uint64_t))   };
   APInt(uint64_t *val, unsigned bits) : BitWidth(bits), pVal(val) {}
   bool isSingleWord() const { return BitWidth <= APINT_BITS_PER_WORD; }
   static unsigned whichWord(unsigned bitPosition) {     return bitPosition / APINT_BITS_PER_WORD;   }
   static unsigned whichBit(unsigned bitPosition) {     return bitPosition % APINT_BITS_PER_WORD;   }
   static uint64_t maskBit(unsigned bitPosition) {     return 1ULL << whichBit(bitPosition);   }
   APInt &clearUnusedBits() {     unsigned wordBits = BitWidth % APINT_BITS_PER_WORD;     if (wordBits == 0) return *this;     uint64_t mask = ~uint64_t(0ULL) >> (APINT_BITS_PER_WORD - wordBits);     if (isSingleWord())       VAL &= mask;     else       pVal[getNumWords() - 1] &= mask;     return *this;   }
   uint64_t getWord(unsigned bitPosition) const {     return isSingleWord() ? VAL : pVal[whichWord(bitPosition)];   }
   static void divide(const APInt LHS, unsigned lhsWords, const APInt &RHS,                      unsigned rhsWords, APInt *Quotient, APInt *Remainder);
   void initSlowCase(unsigned numBits, uint64_t val, bool isSigned);
   bool EqualSlowCase(const APInt &RHS) const;
   bool EqualSlowCase(uint64_t Val) const;
   unsigned countLeadingZerosSlowCase() const;
   unsigned countTrailingOnesSlowCase() const;
   unsigned countPopulationSlowCase() const;
  public:   APInt(unsigned numBits, uint64_t val, bool isSigned = false)       : BitWidth(numBits), VAL(0) {     (void)((!!(BitWidth && "bitwidth too small")) ||            (_wassert(L"BitWidth && \"bitwidth too small\"",                      L"..\\include\\llvm/ADT/APInt.h", 238),             0));     if (isSingleWord())       VAL = val;     else       initSlowCase(numBits, val, isSigned);     clearUnusedBits();   }
   bool isNegative() const { return (*this)[BitWidth - 1]; }
   bool isMinSignedValue() const {     return BitWidth == 1 ? VAL == 1 : isNegative() && isPowerOf2();   }
   bool isIntN(unsigned N) const {     (void)((!!(N && "N == 0 ???")) ||            (_wassert(L"N && \"N == 0 ???\"", L"..\\include\\llvm/ADT/APInt.h",                      377),             0));     return getActiveBits() <= N;   }
   bool isPowerOf2() const {     if (isSingleWord()) return isPowerOf2_64(VAL);     return countPopulationSlowCase() == 1;   }
   bool isSignBit() const { return isMinSignedValue(); }
   APInt operator~() const {     APInt Result(*this);     Result.flipAllBits();     return Result;   }
   APInt sshl_ov(unsigned Amt, bool &Overflow) const;
   bool operator[](unsigned bitPosition) const {     (void)((!!(bitPosition < getBitWidth() && "Bit position out of bounds!")) ||            (_wassert(L"bitPosition < getBitWidth() && \"Bit position out of "                      L"bounds!\"",                      L"..\\include\\llvm/ADT/APInt.h", 943),             0));     return (maskBit(bitPosition) &             (isSingleWord() ? VAL : pVal[whichWord(bitPosition)])) != 0;   }
   bool operator==(const APInt &RHS) const {     (void)((!!(BitWidth == RHS.BitWidth &&                "Comparison requires equal bit widths")) ||            (_wassert(L"BitWidth == RHS.BitWidth && \"Comparison requires equal "                      L"bit widths\"",                      L"..\\include\\llvm/ADT/APInt.h", 958),             0));     if (isSingleWord()) return VAL == RHS.VAL;     return EqualSlowCase(RHS);   }
   bool operator==(uint64_t Val) const {     if (isSingleWord()) return VAL == Val;     return EqualSlowCase(Val);   }
   bool eq(const APInt &RHS) const { return (*this) == RHS; }
   bool ult(const APInt &RHS) const;
   bool ult(uint64_t RHS) const { return ult(APInt(getBitWidth(), RHS)); }
   bool slt(const APInt &RHS) const;
   void flipAllBits() {     if (isSingleWord())       VAL ^= 0xffffffffffffffffui64;     else {       for (unsigned i = 0; i < getNumWords(); ++i)         pVal[i] ^= 0xffffffffffffffffui64;     }     clearUnusedBits();   }
   void flipBit(unsigned bitPosition);
   unsigned getBitWidth() const { return BitWidth; }
   unsigned getNumWords() const { return getNumWords(BitWidth); }
   static unsigned getNumWords(unsigned BitWidth) {     return (BitWidth + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD;   }
   unsigned getActiveBits() const { return BitWidth - countLeadingZeros(); }
   unsigned getActiveWords() const {     unsigned numActiveBits = getActiveBits();     return numActiveBits ? whichWord(numActiveBits - 1) + 1 : 1;   }
   unsigned countLeadingZeros() const {     if (isSingleWord()) {       unsigned unusedBits = APINT_BITS_PER_WORD - BitWidth;       return llvm::countLeadingZeros(VAL) - unusedBits;     }     return countLeadingZerosSlowCase();   }
   unsigned countLeadingOnes() const;
 };
    inline bool operator==(uint64_t V1, const APInt &V2) {
 return V2 == V1;
 }
    inline raw_ostream &operator<<(raw_ostream &OS, const APInt &I) {
 }
    namespace APIntOps {
 inline APInt smin(const APInt &A, const APInt &B) { return A.slt(B) ? A : B; }
 inline APInt Not(const APInt &APIVal) { return ~APIVal; }
 }
    class StringRef;
    enum lostFraction {
   lfExactlyZero,   lfLessThanHalf,   lfExactlyHalf,   lfMoreThanHalf };
    class APFloat {
  public:   typedef signed short ExponentType;
   enum opStatus {     opOK = 0x00,     opInvalidOp = 0x01,     opDivByZero = 0x02,     opOverflow = 0x04,     opUnderflow = 0x08,     opInexact = 0x10   };
   enum fltCategory {     fcInfinity,     fcNaN,     fcNormal,     fcZero   };
   bool isNegative() const { return sign; }
   bool isNormal() const { return !isDenormal() && isFiniteNonZero(); }
   bool isFinite() const { return !isNaN() && !isInfinity(); }
   bool isZero() const { return category == fcZero; }
   bool isDenormal() const;
   bool isInfinity() const { return category == fcInfinity; }
   bool isNaN() const { return category == fcNaN; }
   bool isSignaling() const;
   bool isFiniteNonZero() const { return isFinite() && !isZero(); }
   bool isPosZero() const { return isZero() && !isNegative(); }
   fltCategory category : 3;
   unsigned int sign : 1;
 };
    hash_code hash_value(const APFloat &Arg);
    }
    namespace llvm {
    template <typename From> struct simplify_type {
   typedef From SimpleType;
   static SimpleType &getSimplifiedValue(From &Val) { return Val; }
 };
    template <typename From> struct simplify_type<const From> {
   typedef typename simplify_type<From>::SimpleType NonConstSimpleType;
   typedef typename add_const_past_pointer<NonConstSimpleType>::type SimpleType;
   typedef typename add_lvalue_reference_if_not_pointer<SimpleType>::type       RetType;
   static RetType getSimplifiedValue(const From &Val) {     return simplify_type<From>::getSimplifiedValue(const_cast<From &>(Val));   }
 };
    template <typename To, typename From, typename Enabler = void> struct isa_impl {
 };
    template <typename To, typename From, typename SimpleFrom> struct isa_impl_wrap {
   static bool doit(const From &Val) {     return isa_impl_wrap<To, SimpleFrom,                          typename simplify_type<SimpleFrom>::SimpleType>::         doit(simplify_type<const From>::getSimplifiedValue(Val));   }
 };
    template <class X, class Y> inline bool isa(const Y &Val) {
   return isa_impl_wrap<X, const Y,                        typename simplify_type<const Y>::SimpleType>::doit(Val);
 }
    template <class To, class From> struct cast_retty;
    template <class To, class From> struct cast_retty_impl {
   typedef To *ret_type;
 };
    template <class To, class From> struct cast_retty_impl<To, const From *> {
   typedef const To *ret_type;
 };
    template <class To, class From, class SimpleFrom> struct cast_retty_wrap {
   typedef typename cast_retty<To, SimpleFrom>::ret_type ret_type;
 };
    template <class To, class FromTy> struct cast_retty_wrap<To, FromTy, FromTy> {
   typedef typename cast_retty_impl<To, FromTy>::ret_type ret_type;
 };
    template <class To, class From> struct cast_retty {
   typedef typename cast_retty_wrap<       To, From, typename simplify_type<From>::SimpleType>::ret_type ret_type;
 };
    template <class To, class From, class SimpleFrom> struct cast_convert_val {
   static typename cast_retty<To, From>::ret_type doit(From &Val) {     return cast_convert_val<To, SimpleFrom,                             typename simplify_type<SimpleFrom>::SimpleType>::         doit(simplify_type<From>::getSimplifiedValue(Val));   }
 };
    template <class To, class FromTy> struct cast_convert_val<To, FromTy, FromTy> {
   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {     typename cast_retty<To, FromTy>::ret_type Res2 =         (typename cast_retty<To, FromTy>::ret_type) const_cast<FromTy &>(Val);     return Res2;   }
 };
    template <class X> struct is_simple_type {
   static const bool value =       is_same<X, typename simplify_type<X>::SimpleType>::value;
 };
    template <class X, class Y> inline typename enable_if_c<!is_simple_type<Y>::value,                             typename cast_retty<X, const Y>::ret_type>::type cast(const Y &Val) {
   (void)((!!(isa<X>(Val) && "cast<Ty>() argument of incompatible type!")) ||          (_wassert(               L"isa<X>(Val) && \"cast<Ty>() argument of incompatible type!\"",               L"..\\include\\llvm/Support/Casting.h", 225),           0));
 }
    template <class X, class Y> inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
   return cast_convert_val<X, Y, typename simplify_type<Y>::SimpleType>::doit(       Val);
 }
    template <class X, class Y> inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
 }
    template <class X, class Y> inline typename cast_retty<X, Y *>::ret_type cast_or_null(Y *Val) {
   if (Val == 0) return 0;
   return cast<X>(Val);
 }
    template <class X, class Y> inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
   return isa<X>(Val) ? cast<X>(Val) : 0;
 }
    }
    namespace llvm {
    class Twine;
    struct ScopedFatalErrorHandler {
 };
    __declspec(noreturn) void llvm_unreachable_internal(const char *msg = 0,                                                     const char *file = 0,                                                     unsigned line = 0);
    }
    extern "C" {
    typedef struct LLVMOpaqueType *LLVMTypeRef;
    typedef struct LLVMOpaqueValue *LLVMValueRef;
    typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
    typedef struct LLVMOpaquePassManager *LLVMPassManagerRef;
    typedef struct LLVMOpaquePassRegistry *LLVMPassRegistryRef;
    typedef struct LLVMOpaqueUse *LLVMUseRef;
    typedef enum {
   LLVMZExtAttribute = 1 << 0,   LLVMSExtAttribute = 1 << 1,   LLVMNoReturnAttribute = 1 << 2,   LLVMInRegAttribute = 1 << 3,   LLVMStructRetAttribute = 1 << 4,   LLVMNoUnwindAttribute = 1 << 5,   LLVMNoAliasAttribute = 1 << 6,   LLVMByValAttribute = 1 << 7,   LLVMNestAttribute = 1 << 8,   LLVMReadNoneAttribute = 1 << 9,   LLVMReadOnlyAttribute = 1 << 10,   LLVMNoInlineAttribute = 1 << 11,   LLVMAlwaysInlineAttribute = 1 << 12,   LLVMOptimizeForSizeAttribute = 1 << 13,   LLVMStackProtectAttribute = 1 << 14,   LLVMStackProtectReqAttribute = 1 << 15,   LLVMAlignment = 31 << 16,   LLVMNoCaptureAttribute = 1 << 21,   LLVMNoRedZoneAttribute = 1 << 22,   LLVMNoImplicitFloatAttribute = 1 << 23,   LLVMNakedAttribute = 1 << 24,   LLVMInlineHintAttribute = 1 << 25,   LLVMStackAlignment = 7 << 26,   LLVMReturnsTwice = 1 << 29,   LLVMUWTable = 1 << 30,   LLVMNonLazyBind = 1 << 31 }
    LLVMTypeKind;
    typedef enum {
   LLVMExternalLinkage,   LLVMAvailableExternallyLinkage,   LLVMLinkOnceAnyLinkage,   LLVMLinkOnceODRLinkage,   LLVMLinkOnceODRAutoHideLinkage,   LLVMWeakAnyLinkage,   LLVMWeakODRLinkage,   LLVMAppendingLinkage,   LLVMInternalLinkage,   LLVMPrivateLinkage,   LLVMDLLImportLinkage,   LLVMDLLExportLinkage,   LLVMExternalWeakLinkage,   LLVMGhostLinkage,   LLVMCommonLinkage,   LLVMLinkerPrivateLinkage,   LLVMLinkerPrivateWeakLinkage }
    LLVMLinkage;
    }
    namespace llvm {
    class PointerType;
    template <class GraphType> struct GraphTraits;
    class Type {
  public:   enum TypeID {     VoidTyID = 0,     HalfTyID,     FloatTyID,     DoubleTyID,     X86_FP80TyID,     FP128TyID,     PPC_FP128TyID,     LabelTyID,     MetadataTyID,     X86_MMXTyID,     IntegerTyID,     FunctionTyID,     StructTyID,     ArrayTyID,     PointerTyID,     VectorTyID,     NumTypeIDs,     LastPrimitiveTyID = X86_MMXTyID,     FirstDerivedTyID = IntegerTyID   };
  private:   LLVMContext &Context;
   uint32_t IDAndSubclassData;
  protected:   friend class LLVMContextImpl;
   explicit Type(LLVMContext &C, TypeID tid)       : Context(C), IDAndSubclassData(0), NumContainedTys(0), ContainedTys(0) {     setTypeID(tid);   }
   void setTypeID(TypeID ID) {     IDAndSubclassData = (ID & 0xFF) | (IDAndSubclassData & 0xFFFFFF00);     (void)((!!(getTypeID() == ID && "TypeID data too large for field")) ||            (_wassert(                 L"getTypeID() == ID && \"TypeID data too large for field\"",                 L"..\\include\\llvm/IR/Type.h", 101),             0));   }
   unsigned getSubclassData() const { return IDAndSubclassData >> 8; }
   unsigned NumContainedTys;
   Type *const *ContainedTys;
  public:   void print(raw_ostream &O) const;
   TypeID getTypeID() const { return (TypeID)(IDAndSubclassData & 0xFF); }
   Type *getScalarType();
   typedef Type *const *subtype_iterator;
   subtype_iterator subtype_end() const {     return &ContainedTys[NumContainedTys];   }
   Type *getContainedType(unsigned i) const {     (void)((!!(i < NumContainedTys && "Index out of range!")) ||            (_wassert(L"i < NumContainedTys && \"Index out of range!\"",                      L"..\\include\\llvm/IR/Type.h", 332),             0));     return ContainedTys[i];   }
   typedef Type NodeType;
   typedef Type::subtype_iterator ChildIteratorType;
   static inline NodeType *getEntryNode(Type *T) { return T; }
   static inline ChildIteratorType child_end(NodeType *N) {     return N->subtype_end();   }
 };
    template <> struct GraphTraits<const Type *> {
 };
    inline Type *unwrap(LLVMTypeRef P) {
 return reinterpret_cast<Type *>(P);
 }
    class Value;
    class StringRef;
    class IntegerType : public Type {
 };
    class FunctionType : public Type {
   FunctionType(const FunctionType &) = delete;
   FunctionType(Type *Result, ArrayRef<Type *> Params, bool IsVarArgs);
  public:   static FunctionType *get(Type *Result, ArrayRef<Type *> Params,                            bool isVarArg);
   Type *getReturnType() const { return ContainedTys[0]; }
   typedef Type::subtype_iterator param_iterator;
 };
    class CompositeType : public Type {
 };
    class SequentialType : public CompositeType {
  public:   Type *getElementType() const { return ContainedTys[0]; }
   static inline bool classof(const Type *T) {     return T->getTypeID() == ArrayTyID || T->getTypeID() == PointerTyID ||            T->getTypeID() == VectorTyID;   }
 };
    class ArrayType : public SequentialType {
   uint64_t NumElements;
 };
    class VectorType : public SequentialType {
   static inline bool classof(const Type *T) {     return T->getTypeID() == VectorTyID;   }
 };
    class PointerType : public SequentialType {
 };
    class Twine {
   enum NodeKind {     NullKind,     EmptyKind,     TwineKind,     CStringKind,     StdStringKind,     StringRefKind,     CharKind,     DecUIKind,     DecIKind,     DecULKind,     DecLKind,     DecULLKind,     DecLLKind,     UHexKind   };
   union Child {     const Twine *twine;     const char *cString;     const std::string *stdString;     const StringRef *stringRef;     char character;     unsigned int decUI;     int decI;     const unsigned long *decUL;     const long *decL;     const unsigned long long *decULL;     const long long *decLL;     const uint64_t *uHex;   };
  private:   Child LHS;
   Child RHS;
   unsigned char LHSKind;
   unsigned char RHSKind;
  private:   explicit Twine(NodeKind Kind) : LHSKind(Kind), RHSKind(EmptyKind) {     (void)((!!(isNullary() && "Invalid kind!")) ||            (_wassert(L"isNullary() && \"Invalid kind!\"",                      L"..\\include\\llvm/ADT/Twine.h", 167),             0));   }
   explicit Twine(const Twine &_LHS, const Twine &_RHS)       : LHSKind(TwineKind), RHSKind(TwineKind) {     LHS.twine = &_LHS;     RHS.twine = &_RHS;     (void)((!!(isValid() && "Invalid twine!")) ||            (_wassert(L"isValid() && \"Invalid twine!\"",                      L"..\\include\\llvm/ADT/Twine.h", 175),             0));   }
   explicit Twine(Child _LHS, NodeKind _LHSKind, Child _RHS, NodeKind _RHSKind)       : LHS(_LHS), RHS(_RHS), LHSKind(_LHSKind), RHSKind(_RHSKind) {     (void)((!!(isValid() && "Invalid twine!")) ||            (_wassert(L"isValid() && \"Invalid twine!\"",                      L"..\\include\\llvm/ADT/Twine.h", 182),             0));   }
   bool isNull() const { return getLHSKind() == NullKind; }
   bool isEmpty() const { return getLHSKind() == EmptyKind; }
   bool isNullary() const { return isNull() || isEmpty(); }
   bool isUnary() const { return getRHSKind() == EmptyKind && !isNullary(); }
   bool isBinary() const {     return getLHSKind() != NullKind && getRHSKind() != EmptyKind;   }
   bool isValid() const {     if (isNullary() && getRHSKind() != EmptyKind) return false;     if (getRHSKind() == NullKind) return false;     if (getRHSKind() != EmptyKind && getLHSKind() == EmptyKind) return false;     if (getLHSKind() == TwineKind && !LHS.twine->isBinary()) return false;     if (getRHSKind() == TwineKind && !RHS.twine->isBinary()) return false;     return true;   }
   NodeKind getLHSKind() const { return (NodeKind)LHSKind; }
   NodeKind getRHSKind() const { return (NodeKind)RHSKind; }
   void printOneChild(raw_ostream &OS, Child Ptr, NodeKind Kind) const;
  public:   Twine() : LHSKind(EmptyKind), RHSKind(EmptyKind) {     (void)((!!(isValid() && "Invalid twine!")) ||            (_wassert(L"isValid() && \"Invalid twine!\"",                      L"..\\include\\llvm/ADT/Twine.h", 255),             0));   }
   Twine(const char *Str) : RHSKind(EmptyKind) {     if (Str[0] != '\0') {       LHS.cString = Str;       LHSKind = CStringKind;     } else       LHSKind = EmptyKind;     (void)((!!(isValid() && "Invalid twine!")) ||            (_wassert(L"isValid() && \"Invalid twine!\"",                      L"..\\include\\llvm/ADT/Twine.h", 271),             0));   }
   Twine(const StringRef &Str) : LHSKind(StringRefKind), RHSKind(EmptyKind) {     LHS.stringRef = &Str;     (void)((!!(isValid() && "Invalid twine!")) ||            (_wassert(L"isValid() && \"Invalid twine!\"",                      L"..\\include\\llvm/ADT/Twine.h", 285),             0));   }
   explicit Twine(char Val) : LHSKind(CharKind), RHSKind(EmptyKind) {     LHS.character = Val;   }
   Twine concat(const Twine &Suffix) const;
   std::string str() const;
   void dumpRepr() const;
 };
    inline Twine Twine::concat(const Twine &Suffix) const {
   Child NewLHS, NewRHS;
   NewLHS.twine = this;
   NodeKind NewLHSKind = TwineKind, NewRHSKind = TwineKind;
   if (isUnary()) {     NewLHS = LHS;     NewLHSKind = getLHSKind();   }
   return Twine(NewLHS, NewLHSKind, NewRHS, NewRHSKind);
 }
    inline Twine operator+(const Twine &LHS, const Twine &RHS) {
   return LHS.concat(RHS);
 }
    template <typename NodeTy> struct ilist_traits;
    template <typename NodeTy> class ilist_half_node {
   friend struct ilist_traits<NodeTy>;
   NodeTy *Prev;
  protected:   NodeTy *getPrev() { return Prev; }
   const NodeTy *getPrev() const { return Prev; }
   void setPrev(NodeTy *P) { Prev = P; }
 };
    template <typename NodeTy> struct ilist_nextprev_traits;
    template <typename NodeTy> class ilist_node : private ilist_half_node<NodeTy> {
   friend struct ilist_nextprev_traits<NodeTy>;
   friend struct ilist_traits<NodeTy>;
   NodeTy *Next;
   NodeTy *getNext() { return Next; }
   const NodeTy *getNext() const { return Next; }
   void setNext(NodeTy *N) { Next = N; }
 };
    class User;
    class Use;
    template <typename> struct simplify_type;
    template <> class PointerLikeTypeTraits<Use **> {
  public:   static inline void *getAsVoidPointer(Use **P) { return P; }
   static inline Use **getFromVoidPointer(void *P) {     return static_cast<Use **>(P);   }
   enum {     NumLowBitsAvailable = 2   };
 };
    class Use {
   enum PrevPtrTag {     zeroDigitTag,     oneDigitTag,     stopTag,     fullStopTag   };
   Use(PrevPtrTag tag) : Val(0) { Prev.setInt(tag); }
  public:   operator Value *() const { return Val; }
   Value *get() const { return Val; }
   User *getUser() const;
   inline void set(Value *Val);
   Value *operator=(Value *RHS) {     set(RHS);     return RHS;   }
   const Use &operator=(const Use &RHS) {     set(RHS.Val);     return *this;   }
   const Value *operator->() const { return Val; }
   Use *getNext() const { return Next; }
   Value *Val;
   Use *Next;
   PointerIntPair<Use **, 2, PrevPtrTag> Prev;
   void setPrev(Use **NewPrev) { Prev.setPointer(NewPrev); }
   typedef Value *SimpleType;
   static SimpleType getSimplifiedValue(const Use &Val) { return Val.get(); }
 };
    template <typename UserTy> class value_use_iterator     : public std::iterator<std::forward_iterator_tag, UserTy *, ptrdiff_t> {
   typedef std::iterator<std::forward_iterator_tag, UserTy *, ptrdiff_t> super;
   typedef value_use_iterator<UserTy> _Self;
   Use *U;
   explicit value_use_iterator(Use *u) : U(u) {}
   friend class Value;
  public:   typedef typename super::reference reference;
   bool operator!=(const _Self &x) const { return !operator==(x); }
   bool atEnd() const { return U == 0; }
   _Self &operator++() {     (void)((!!(U && "Cannot increment end iterator!")) ||            (_wassert(L"U && \"Cannot increment end iterator!\"",                      L"..\\include\\llvm/IR/Use.h", 194),             0));     U = U->getNext();     return *this;   }
   _Self operator++(int) {     _Self tmp = *this;     ++*this;     return tmp;   }
   UserTy *operator*() const {     (void)((!!(U && "Cannot dereference end iterator!")) ||            (_wassert(L"U && \"Cannot dereference end iterator!\"",                      L"..\\include\\llvm/IR/Use.h", 204),             0));     return U->getUser();   }
   Use &getUse() const { return *U; }
   unsigned getOperandNo() const;
 };
    inline Use *unwrap(LLVMUseRef P) {
 return reinterpret_cast<Use *>(P);
 }
    class Argument;
    class AssemblyAnnotationWriter;
    class BasicBlock;
    class Function;
    class GlobalAlias;
    class Instruction;
    class LLVMContext;
    class Value {
   const unsigned char SubclassID;
   unsigned char HasValueHandle : 1;
  protected:   unsigned char SubclassOptionalData : 7;
  private:   unsigned short SubclassData;
   Type *VTy;
   Use *UseList;
   friend class ValueSymbolTable;
   friend class ValueHandleBase;
  public:   virtual ~Value();
   void dump() const;
   void print(raw_ostream &O, AssemblyAnnotationWriter *AAW = 0) const;
   Type *getType() const { return VTy; }
   LLVMContext &getContext() const;
   StringRef getName() const;
   typedef value_use_iterator<User> use_iterator;
   typedef value_use_iterator<const User> const_use_iterator;
   use_iterator use_begin() { return use_iterator(UseList); }
   const_use_iterator use_begin() const { return const_use_iterator(UseList); }
   use_iterator use_end() { return use_iterator(0); }
   enum ValueTy {     ArgumentVal,     BasicBlockVal,     FunctionVal,     GlobalAliasVal,     GlobalVariableVal,     UndefValueVal,     BlockAddressVal,     ConstantExprVal,     ConstantAggregateZeroVal,     ConstantDataArrayVal,     ConstantDataVectorVal,     ConstantIntVal,     ConstantFPVal,     ConstantArrayVal,     ConstantStructVal,     ConstantVectorVal,     ConstantPointerNullVal,     MDNodeVal,     MDStringVal,     InlineAsmVal,     PseudoSourceValueVal,     FixedStackPseudoSourceValueVal,     InstructionVal,     ConstantFirstVal = FunctionVal,     ConstantLastVal = ConstantPointerNullVal   };
   unsigned getValueID() const { return SubclassID; }
   unsigned getRawSubclassOptionalData() const { return SubclassOptionalData; }
  protected:   unsigned short getSubclassDataFromValue() const { return SubclassData; }
   void setValueSubclassData(unsigned short D) { SubclassData = D; }
 };
    inline raw_ostream &operator<<(raw_ostream &OS, const Value &V) {
   V.print(OS);
 };
    template <> struct isa_impl<Instruction, Value> {
   static inline bool doit(const Value &Val) {     return Val.getValueID() >= Value::InstructionVal;   }
 };
    template <> class PointerLikeTypeTraits<Value *> {
   typedef Value *PT;
  public:   static inline void *getAsVoidPointer(PT P) { return P; }
   static inline PT getFromVoidPointer(void *P) { return static_cast<PT>(P); }
   enum {     NumLowBitsAvailable = 2   };
 };
    inline Value *unwrap(LLVMValueRef P) {
 }
    template <typename T> inline T *unwrap(LLVMValueRef P) {
   return reinterpret_cast<T **>(Vals);
 }
    }
    namespace llvm {
    template <class> struct OperandTraits;
    class User : public Value {
   User(const User &) = delete;
   void *operator new(size_t) = delete;
   template <unsigned>   friend struct HungoffOperandTraits;
  protected:   Use *OperandList;
   unsigned NumOperands;
   void *operator new(size_t s, unsigned Us);
   template <int Idx>   const Use &Op() const {     return OpFrom<Idx>(this);   }
  public:   Value *getOperand(unsigned i) const {     (void)((!!(i < NumOperands && "getOperand() out of range!")) ||            (_wassert(L"i < NumOperands && \"getOperand() out of range!\"",                      L"..\\include\\llvm/IR/User.h", 89),             0));     return OperandList[i];   }
   unsigned getNumOperands() const { return NumOperands; }
   typedef Use *op_iterator;
   typedef const Use *const_op_iterator;
   inline const_op_iterator op_begin() const { return OperandList; }
   inline op_iterator op_end() { return OperandList + NumOperands; }
   typedef Value *SimpleType;
   static SimpleType getSimplifiedValue(User::op_iterator &Val) {     return Val->get();   }
 };
    template <> struct simplify_type<User::const_op_iterator> {
 };
    template <typename UserTy> unsigned value_use_iterator<UserTy>::getOperandNo() const {
   return U - U->getUser()->op_begin();
 }
    template <typename T> struct DenseMapInfo;
    class MDNode;
    class LLVMContext;
    class DebugLoc {
 };
    class Instruction : public User, public ilist_node<Instruction> {
   void operator=(const Instruction &) = delete;
   BasicBlock *Parent;
   DebugLoc DbgLoc;
   enum {     HasMetadataBit = 1 << 15   };
  public:   ~Instruction();
   Instruction *use_back() { return cast<Instruction>(*use_begin()); }
   inline const BasicBlock *getParent() const { return Parent; }
   inline BasicBlock *getParent() { return Parent; }
   unsigned getOpcode() const { return getValueID() - InstructionVal; }
   const char *getOpcodeName() const { return getOpcodeName(getOpcode()); }
   static const char *getOpcodeName(unsigned OpCode);
   static inline bool isTerminator(unsigned OpCode) {     return OpCode >= TermOpsBegin && OpCode < TermOpsEnd;   }
   enum TermOps {     TermOpsBegin = 1,     Ret = 1,     Br = 2,     Switch = 3,     IndirectBr = 4,     Invoke = 5,     Resume = 6,     Unreachable = 7,     TermOpsEnd = 7 + 1   };
   enum BinaryOps {     BinaryOpsBegin = 8,     Add = 8,     FAdd = 9,     Sub = 10,     FSub = 11,     Mul = 12,     FMul = 13,     UDiv = 14,     SDiv = 15,     FDiv = 16,     URem = 17,     SRem = 18,     FRem = 19,     Shl = 20,     LShr = 21,     AShr = 22,     And = 23,     Or = 24,     Xor = 25,     BinaryOpsEnd = 25 + 1   };
   enum MemoryOps {     MemoryOpsBegin = 26,     Alloca = 26,     Load = 27,     Store = 28,     GetElementPtr = 29,     Fence = 30,     AtomicCmpXchg = 31,     AtomicRMW = 32,     MemoryOpsEnd = 32 + 1   };
   enum OtherOps {     OtherOpsBegin = 45,     ICmp = 45,     FCmp = 46,     PHI = 47,     Call = 48,     Select = 49,     UserOp1 = 50,     UserOp2 = 51,     VAArg = 52,     ExtractElement = 53,     InsertElement = 54,     ShuffleVector = 55,     ExtractValue = 56,     InsertValue = 57,     LandingPad = 58,     OtherOpsEnd = 58 + 1   };
  private:   void setValueSubclassData(unsigned short D) {     Value::setValueSubclassData(D);   }
   void setParent(BasicBlock *P);
  protected:   void setInstructionSubclassData(unsigned short D) {     (void)((!!((D & HasMetadataBit) == 0 &&                "Out of range value put into field")) ||            (_wassert(L"(D & HasMetadataBit) == 0 && \"Out of range value put "                      L"into field\"",                      L"..\\include\\llvm/IR/Instruction.h", 437),             0));     setValueSubclassData((getSubclassDataFromValue() & HasMetadataBit) | D);   }
   unsigned getSubclassDataFromInstruction() const {     return getSubclassDataFromValue() & ~HasMetadataBit;   }
   Instruction(Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,               Instruction *InsertBefore = 0);
   Instruction(Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,               BasicBlock *InsertAtEnd);
   virtual Instruction *clone_impl() const = 0;
 };
    template <> class PointerLikeTypeTraits<Instruction *> {
   enum {     NumLowBitsAvailable = 2   };
 };
    }
    namespace llvm {
    template <typename SubClass, unsigned ARITY> struct FixedNumOperandTraits {
   static Use *op_begin(SubClass *U) {     return reinterpret_cast<Use *>(U) - ARITY;   }
   static Use *op_end(SubClass *U) { return reinterpret_cast<Use *>(U); }
   static unsigned operands(const User *) { return ARITY; }
 };
    template <typename SubClass, unsigned MINARITY = 0> struct VariadicOperandTraits {
   static Use *op_begin(SubClass *U) {     return reinterpret_cast<Use *>(U) -            static_cast<User *>(U)->getNumOperands();   }
   static Use *op_end(SubClass *U) { return reinterpret_cast<Use *>(U); }
   static unsigned operands(const User *U) { return U->getNumOperands(); }
 };
    template <unsigned MINARITY = 1> struct HungoffOperandTraits {
   static Use *op_begin(User *U) { return U->OperandList; }
   static Use *op_end(User *U) { return U->OperandList + U->getNumOperands(); }
   static unsigned operands(const User *U) { return U->getNumOperands(); }
 };
    class TerminatorInst : public Instruction {
  protected:   TerminatorInst(Type *Ty, Instruction::TermOps iType, Use *Ops,                  unsigned NumOps, Instruction *InsertBefore = 0)       : Instruction(Ty, iType, Ops, NumOps, InsertBefore) {}
   ~TerminatorInst();
   virtual BasicBlock *getSuccessorV(unsigned idx) const = 0;
   virtual unsigned getNumSuccessorsV() const = 0;
   virtual void setSuccessorV(unsigned idx, BasicBlock *B) = 0;
   virtual TerminatorInst *clone_impl() const = 0;
  public:   unsigned getNumSuccessors() const { return getNumSuccessorsV(); }
   BasicBlock *getSuccessor(unsigned idx) const { return getSuccessorV(idx); }
   void setSuccessor(unsigned idx, BasicBlock *B) { setSuccessorV(idx, B); }
   static inline bool classof(const Value *V) {     return isa<Instruction>(V) && classof(cast<Instruction>(V));   }
 };
    class UnaryInstruction : public Instruction {
   void *operator new(size_t, unsigned) = delete;
  protected:   UnaryInstruction(Type *Ty, unsigned iType, Value *V, Instruction *IB = 0)       : Instruction(Ty, iType, &Op<0>(), 1, IB) {     Op<0>() = V;   }
  public:   inline Value *getOperand(unsigned) const;
   inline void setOperand(unsigned, Value *);
   inline op_iterator op_begin();
  protected:   template <int>   inline Use &Op();
   static inline bool classof(const Value *V) {     return isa<Instruction>(V) && classof(cast<Instruction>(V));   }
 };
    template <> struct OperandTraits<UnaryInstruction> : public FixedNumOperandTraits<     UnaryInstruction, 1> {
};
    UnaryInstruction::op_iterator UnaryInstruction::op_begin() {
 }
    Value *UnaryInstruction::getOperand(unsigned i_nocapture) const {
   (void)((!!(i_nocapture < OperandTraits<UnaryInstruction>::operands(this) &&              "getOperand() out of range!")) ||          (_wassert(L"i_nocapture < "                    L"OperandTraits<UnaryInstruction>::operands(this) && "                    L"\"getOperand() out of range!\"",                    L"..\\include\\llvm/IR/InstrTypes.h", 132),           0));
 }
    void UnaryInstruction::setOperand(unsigned i_nocapture, Value *Val_nocapture) {
   OperandTraits<UnaryInstruction>::op_begin(this)[i_nocapture] = Val_nocapture;
 }
    class BinaryOperator : public Instruction {
   void *operator new(size_t, unsigned) = delete;
   inline op_iterator op_end();
   inline const_op_iterator op_end() const;
 };
    BinaryOperator::op_iterator BinaryOperator::op_end() {
}
    class CastInst : public UnaryInstruction {
   static inline bool classof(const Value *V) {     return isa<Instruction>(V) && classof(cast<Instruction>(V));   }
 };
    class CmpInst : public Instruction {
  public:   enum Predicate {     FCMP_FALSE = 0,     FCMP_OEQ = 1,     FCMP_OGT = 2,     FCMP_OGE = 3,     FCMP_OLT = 4,     FCMP_OLE = 5,     FCMP_ONE = 6,     FCMP_ORD = 7,     FCMP_UNO = 8,     FCMP_UEQ = 9,     FCMP_UGT = 10,     FCMP_UGE = 11,     FCMP_ULT = 12,     FCMP_ULE = 13,     FCMP_UNE = 14,     FCMP_TRUE = 15,     FIRST_FCMP_PREDICATE = FCMP_FALSE,     LAST_FCMP_PREDICATE = FCMP_TRUE,     BAD_FCMP_PREDICATE = FCMP_TRUE + 1,     ICMP_EQ = 32,     ICMP_NE = 33,     ICMP_UGT = 34,     ICMP_UGE = 35,     ICMP_ULT = 36,     ICMP_ULE = 37,     ICMP_SGT = 38,     ICMP_SGE = 39,     ICMP_SLT = 40,     ICMP_SLE = 41,     FIRST_ICMP_PREDICATE = ICMP_EQ,     LAST_ICMP_PREDICATE = ICMP_SLE,     BAD_ICMP_PREDICATE = ICMP_SLE + 1   };
   static Predicate getSwappedPredicate(Predicate pred);
  public:   inline Value *getOperand(unsigned) const;
   inline op_iterator op_begin();
   inline const_op_iterator op_begin() const;
 };
    template <> struct OperandTraits<CmpInst> : public FixedNumOperandTraits<CmpInst, 2> {
};
    CmpInst::op_iterator CmpInst::op_begin() {
   return OperandTraits<CmpInst>::op_begin(this);
 }
    Value *CmpInst::getOperand(unsigned i_nocapture) const {
   (void)((!!(i_nocapture < OperandTraits<CmpInst>::operands(this) &&              "getOperand() out of range!")) ||          (_wassert(L"i_nocapture < OperandTraits<CmpInst>::operands(this) && "                    L"\"getOperand() out of range!\"",                    L"..\\include\\llvm/IR/InstrTypes.h", 853),           0));
 }
    }
    namespace llvm {
    class APInt;
    class ConstantInt;
    enum AtomicOrdering {
 };
    class AtomicCmpXchgInst : public Instruction {
   void *operator new(size_t, unsigned) = delete;
  public:   inline Value *getOperand(unsigned) const;
   inline void setOperand(unsigned, Value *);
   inline op_iterator op_begin();
  protected:   template <int>   inline Use &Op();
   template <int>   inline const Use &Op() const;
 };
    template <> struct OperandTraits<AtomicCmpXchgInst> : public FixedNumOperandTraits<     AtomicCmpXchgInst, 3> {
};
    AtomicCmpXchgInst::op_iterator AtomicCmpXchgInst::op_begin() {
   return OperandTraits<AtomicCmpXchgInst>::op_begin(this);
   return OperandTraits<AtomicCmpXchgInst>::op_begin(       const_cast<AtomicCmpXchgInst *>(this));
 }
    Value *AtomicCmpXchgInst::getOperand(unsigned i_nocapture) const {
 }
    void AtomicCmpXchgInst::setOperand(unsigned i_nocapture, Value *Val_nocapture) {
   (void)((!!(i_nocapture < OperandTraits<AtomicCmpXchgInst>::operands(this) &&              "setOperand() out of range!")) ||          (_wassert(L"i_nocapture < "                    L"OperandTraits<AtomicCmpXchgInst>::operands(this) && "                    L"\"setOperand() out of range!\"",                    L"..\\include\\llvm/IR/Instructions.h", 546),           0));
 }
    template <int Idx_nocapture> Use &AtomicCmpXchgInst::Op() {
   return this->OpFrom<Idx_nocapture>(this);
 }
    class AtomicRMWInst : public Instruction {
   void *operator new(size_t, unsigned) = delete;
  public:   inline Value *getOperand(unsigned) const;
   inline void setOperand(unsigned, Value *);
   inline op_iterator op_begin();
 };
    template <> struct OperandTraits<AtomicRMWInst> : public FixedNumOperandTraits<     AtomicRMWInst, 2> {
};
    AtomicRMWInst::op_iterator AtomicRMWInst::op_begin() {
   return OperandTraits<AtomicRMWInst>::op_begin(this);
 }
    Value *AtomicRMWInst::getOperand(unsigned i_nocapture) const {
   (void)((!!(i_nocapture < OperandTraits<AtomicRMWInst>::operands(this) &&              "getOperand() out of range!")) ||          (_wassert(L"i_nocapture < "                    L"OperandTraits<AtomicRMWInst>::operands(this) && "                    L"\"getOperand() out of range!\"",                    L"..\\include\\llvm/IR/Instructions.h", 692),           0));
 }
    void AtomicRMWInst::setOperand(unsigned i_nocapture, Value *Val_nocapture) {
   OperandTraits<AtomicRMWInst>::op_begin(this)[i_nocapture] = Val_nocapture;
 }
    inline Type *checkGEPType(Type *Ty) {
 }
    class GetElementPtrInst : public Instruction {
   GetElementPtrInst(const GetElementPtrInst &GEPI);
   inline op_iterator op_begin();
 };
    template <> struct OperandTraits<GetElementPtrInst> : public VariadicOperandTraits<     GetElementPtrInst, 1> {
};
    GetElementPtrInst::op_iterator GetElementPtrInst::op_begin() {
   return OperandTraits<GetElementPtrInst>::op_begin(this);
 };
    class CallInst : public Instruction {
   AttributeSet AttributeList;
   inline CallInst(Value *Func, ArrayRef<Value *> Args, const Twine &NameStr,                   BasicBlock *InsertAtEnd);
   CallInst(Value *F, Value *Actual, const Twine &NameStr,            Instruction *InsertBefore);
   inline const_op_iterator op_end() const;
  protected:   template <int>   inline Use &Op();
   void setInstructionSubclassData(unsigned short D) {     Instruction::setInstructionSubclassData(D);   }
 };
    template <> struct OperandTraits<CallInst> : public VariadicOperandTraits<CallInst, 1> {
};
    CallInst::CallInst(Value *Func, ArrayRef<Value *> Args, const Twine &NameStr,                    BasicBlock *InsertAtEnd)     : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())                                          ->getElementType())->getReturnType(),                   Instruction::Call,                   OperandTraits<CallInst>::op_end(this) - (Args.size() + 1),                   unsigned(Args.size() + 1), InsertAtEnd) {
 }
    template <int Idx_nocapture> Use &CallInst::Op() {
   return this->OpFrom<Idx_nocapture>(this);
 }
    class SelectInst : public Instruction {
   static const char *areInvalidOperands(Value *Cond, Value *True, Value *False);
  public:   inline Value *getOperand(unsigned) const;
   inline void setOperand(unsigned, Value *);
   inline op_iterator op_begin();
   inline const_op_iterator op_begin() const;
 };
    template <> struct OperandTraits<SelectInst> : public FixedNumOperandTraits<SelectInst, 3> {
 };
    SelectInst::op_iterator SelectInst::op_begin() {
   return OperandTraits<SelectInst>::op_begin(this);
 }
    Value *SelectInst::getOperand(unsigned i_nocapture) const {
   (void)((!!(i_nocapture < OperandTraits<SelectInst>::operands(this) &&              "getOperand() out of range!")) ||          (_wassert(L"i_nocapture < OperandTraits<SelectInst>::operands(this) "                    L"&& \"getOperand() out of range!\"",                    L"..\\include\\llvm/IR/Instructions.h", 1503),           0));
   return cast_or_null<Value>(OperandTraits<SelectInst>::op_begin(       const_cast<SelectInst *>(this))[i_nocapture].get());
 }
    void SelectInst::setOperand(unsigned i_nocapture, Value *Val_nocapture) {
   (void)((!!(i_nocapture < OperandTraits<SelectInst>::operands(this) &&              "setOperand() out of range!")) ||          (_wassert(L"i_nocapture < OperandTraits<SelectInst>::operands(this) "                    L"&& \"setOperand() out of range!\"",                    L"..\\include\\llvm/IR/Instructions.h", 1503),           0));
 }
    class VAArgInst : public UnaryInstruction {
   static inline bool classof(const Value *V) {     return isa<Instruction>(V) && classof(cast<Instruction>(V));   }
 };
    class ExtractElementInst : public Instruction {
  public:   inline Value *getOperand(unsigned) const;
   inline void setOperand(unsigned, Value *);
   inline op_iterator op_begin();
  protected:   template <int>   inline Use &Op();
   static inline bool classof(const Value *V) {     return isa<Instruction>(V) && classof(cast<Instruction>(V));   }
 };
    template <> struct OperandTraits<ExtractElementInst> : public FixedNumOperandTraits<     ExtractElementInst, 2> {
};
    ExtractElementInst::op_iterator ExtractElementInst::op_begin() {
   return OperandTraits<ExtractElementInst>::op_begin(this);
 }
    Value *ExtractElementInst::getOperand(unsigned i_nocapture) const {
   (void)((!!(i_nocapture < OperandTraits<ExtractElementInst>::operands(this) &&              "getOperand() out of range!")) ||          (_wassert(L"i_nocapture < "                    L"OperandTraits<ExtractElementInst>::operands(this) && "                    L"\"getOperand() out of range!\"",                    L"..\\include\\llvm/IR/Instructions.h", 1599),           0));
 }
    void ExtractElementInst::setOperand(unsigned i_nocapture,                                     Value *Val_nocapture) {
   OperandTraits<ExtractElementInst>::op_begin(this)[i_nocapture] =       Val_nocapture;
 }
    template <int Idx_nocapture> Use &ExtractElementInst::Op() {
   return this->OpFrom<Idx_nocapture>(this);
 }
    class InsertElementInst : public Instruction {
   inline op_iterator op_begin();
};
    InsertElementInst::op_iterator InsertElementInst::op_begin() {
 }
    class ShuffleVectorInst : public Instruction {
  protected:   virtual ShuffleVectorInst *clone_impl() const;
   VectorType *getType() const {     return cast<VectorType>(Instruction::getType());   }
  public:   inline Value *getOperand(unsigned) const;
 };
    Value *ShuffleVectorInst::getOperand(unsigned i_nocapture) const {
 }
    class ExtractValueInst : public UnaryInstruction {
   SmallVector<unsigned, 4> Indices;
   void init(ArrayRef<unsigned> Idxs, const Twine &NameStr);
   inline ExtractValueInst(Value *Agg, ArrayRef<unsigned> Idxs,                           const Twine &NameStr, Instruction *InsertBefore);
   inline ExtractValueInst(Value *Agg, ArrayRef<unsigned> Idxs,                           const Twine &NameStr, BasicBlock *InsertAtEnd);
   void *operator new(size_t s) { return User::operator new(s, 1); }
  protected:   virtual ExtractValueInst *clone_impl() const;
   static ExtractValueInst *Create(Value *Agg, ArrayRef<unsigned> Idxs,                                   const Twine &NameStr,                                   BasicBlock *InsertAtEnd) {     return new ExtractValueInst(Agg, Idxs, NameStr, InsertAtEnd);   }
   static Type *getIndexedType(Type *Agg, ArrayRef<unsigned> Idxs);
 };
    ExtractValueInst::ExtractValueInst(Value *Agg, ArrayRef<unsigned> Idxs,                                    const Twine &NameStr,                                    Instruction *InsertBefore)     : UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)),                        ExtractValue, Agg, InsertBefore) {
 }
    class InsertValueInst : public Instruction {
   void init(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,             const Twine &NameStr);
   inline InsertValueInst(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,                          const Twine &NameStr, Instruction *InsertBefore);
   inline InsertValueInst(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,                          const Twine &NameStr, BasicBlock *InsertAtEnd);
 };
    template <> struct OperandTraits<InsertValueInst> : public FixedNumOperandTraits<     InsertValueInst, 2> {
};
    InsertValueInst::InsertValueInst(Value *Agg, Value *Val,                                  ArrayRef<unsigned> Idxs, const Twine &NameStr,                                  Instruction *InsertBefore)     : Instruction(Agg->getType(), InsertValue,                   OperandTraits<InsertValueInst>::op_begin(this), 2,                   InsertBefore) {
   init(Agg, Val, Idxs, NameStr);
 }
    class PHINode : public Instruction {
   ~PHINode();
  public:   inline Value *getOperand(unsigned) const;
   inline void setOperand(unsigned, Value *);
   inline op_iterator op_begin();
   inline const_op_iterator op_begin() const;
 };
    template <> struct OperandTraits<PHINode> : public HungoffOperandTraits<2> {
};
    PHINode::op_iterator PHINode::op_begin() {
   return OperandTraits<PHINode>::op_begin(this);
 }
    Value *PHINode::getOperand(unsigned i_nocapture) const {
   (void)((!!(i_nocapture < OperandTraits<PHINode>::operands(this) &&              "getOperand() out of range!")) ||          (_wassert(L"i_nocapture < OperandTraits<PHINode>::operands(this) && "                    L"\"getOperand() out of range!\"",                    L"..\\include\\llvm/IR/Instructions.h", 2170),           0));
 }
    void PHINode::setOperand(unsigned i_nocapture, Value *Val_nocapture) {
   OperandTraits<PHINode>::op_begin(this)[i_nocapture] = Val_nocapture;
 }
    class LandingPadInst : public Instruction {
   unsigned ReservedSpace;
  public:   inline Value *getOperand(unsigned) const;
   inline void setOperand(unsigned, Value *);
   inline op_iterator op_begin();
   static inline bool classof(const Value *V) {     return isa<Instruction>(V) && classof(cast<Instruction>(V));   }
 };
    template <> struct OperandTraits<LandingPadInst> : public HungoffOperandTraits<2> {
};
    LandingPadInst::op_iterator LandingPadInst::op_begin() {
 }
    void LandingPadInst::setOperand(unsigned i_nocapture, Value *Val_nocapture) {
   OperandTraits<LandingPadInst>::op_begin(this)[i_nocapture] = Val_nocapture;
 }
    class ReturnInst : public TerminatorInst {
  public:   inline Value *getOperand(unsigned) const;
   inline void setOperand(unsigned, Value *);
   inline op_iterator op_begin();
   virtual void setSuccessorV(unsigned idx, BasicBlock *B);
 };
    template <> struct OperandTraits<ReturnInst> : public VariadicOperandTraits<ReturnInst> {
};
    ReturnInst::op_iterator ReturnInst::op_begin() {
 }
    Value *ReturnInst::getOperand(unsigned i_nocapture) const {
   (void)((!!(i_nocapture < OperandTraits<ReturnInst>::operands(this) &&              "getOperand() out of range!")) ||          (_wassert(L"i_nocapture < OperandTraits<ReturnInst>::operands(this) "                    L"&& \"getOperand() out of range!\"",                    L"..\\include\\llvm/IR/Instructions.h", 2347),           0));
 }
    void ReturnInst::setOperand(unsigned i_nocapture, Value *Val_nocapture) {
   OperandTraits<ReturnInst>::op_begin(this)[i_nocapture] = Val_nocapture;
 }
    class BranchInst : public TerminatorInst {
   BranchInst(const BranchInst &BI);
   inline op_iterator op_begin();
   inline const_op_iterator op_begin() const;
   inline const_op_iterator op_end() const;
  protected:   template <int>   inline Use &Op();
   template <int>   inline const Use &Op() const;
  public:   inline unsigned getNumOperands() const;
   bool isUnconditional() const { return getNumOperands() == 1; }
   bool isConditional() const { return getNumOperands() == 3; }
   Value *getCondition() const {     (void)((!!(isConditional() &&                "Cannot get condition of an uncond branch!")) ||            (_wassert(L"isConditional() && \"Cannot get condition of an uncond "                      L"branch!\"",                      L"..\\include\\llvm/IR/Instructions.h", 2401),             0));     return Op<-3>();   }
   void setCondition(Value *V) {     (void)((!!(isConditional() &&                "Cannot set condition of unconditional branch!")) ||            (_wassert(L"isConditional() && \"Cannot set condition of "                      L"unconditional branch!\"",                      L"..\\include\\llvm/IR/Instructions.h", 2406),             0));     Op<-3>() = V;   }
   virtual void setSuccessorV(unsigned idx, BasicBlock *B);
 };
    template <> struct OperandTraits<BranchInst> : public VariadicOperandTraits<BranchInst, 1> {
 };
    BranchInst::op_iterator BranchInst::op_begin() {
}
    class SwitchInst : public TerminatorInst {
   void *operator new(size_t, unsigned) = delete;
  protected:   virtual SwitchInst *clone_impl() const;
  public:   static const unsigned DefaultPseudoIndex = static_cast<unsigned>(~0L - 1);
   template <class SwitchInstTy, class ConstantIntTy, class BasicBlockTy>   class CaseIteratorT {    protected:     SwitchInstTy *SI;     unsigned Index;    public:     typedef CaseIteratorT<SwitchInstTy, ConstantIntTy, BasicBlockTy> Self;     CaseIteratorT(SwitchInstTy *SI, unsigned CaseNum) {       this->SI = SI;       Index = CaseNum;     }     static Self fromSuccessorIndex(SwitchInstTy *SI, unsigned SuccessorIndex) {       (void)((!!(SuccessorIndex < SI->getNumSuccessors() &&                  "Successor index # out of range!")) ||              (_wassert(L"SuccessorIndex < SI->getNumSuccessors() && "                        L"\"Successor index # out of range!\"",                        L"..\\include\\llvm/IR/Instructions.h", 2511),               0));       return SuccessorIndex != 0 ? Self(SI, SuccessorIndex - 1)                                  : Self(SI, DefaultPseudoIndex);     }     ConstantIntTy *getCaseValue() {       (void)((!!(Index < SI->getNumCases() &&                  "Index out the number of cases.")) ||              (_wassert(L"Index < SI->getNumCases() && \"Index out the number "                        L"of cases.\"",                        L"..\\include\\llvm/IR/Instructions.h", 2519),               0));       return reinterpret_cast<ConstantIntTy *>(SI->getOperand(2 + Index * 2));     }     BasicBlockTy *getCaseSuccessor() {       (void)((!!((Index < SI->getNumCases() || Index == DefaultPseudoIndex) &&                  "Index out the number of cases.")) ||              (_wassert(L"(Index < SI->getNumCases() || Index == "                        L"DefaultPseudoIndex) && \"Index out the number of "                        L"cases.\"",                        L"..\\include\\llvm/IR/Instructions.h", 2527),               0));       return SI->getSuccessor(getSuccessorIndex());     }     unsigned getCaseIndex() const { return Index; }     unsigned getSuccessorIndex() const {       (void)((!!((Index == DefaultPseudoIndex || Index < SI->getNumCases()) &&                  "Index out the number of cases.")) ||              (_wassert(L"(Index == DefaultPseudoIndex || Index < "                        L"SI->getNumCases()) && \"Index out the number of "                        L"cases.\"",                        L"..\\include\\llvm/IR/Instructions.h", 2537),               0));       return Index != DefaultPseudoIndex ? Index + 1 : 0;     }     Self operator++() {       (void)((!!(Index + 1 <= SI->getNumCases() &&                  "Index out the number of cases.")) ||              (_wassert(L"Index+1 <= SI->getNumCases() && \"Index out the "                        L"number of cases.\"",                        L"..\\include\\llvm/IR/Instructions.h", 2544),               0));       ++Index;       return *this;     }     Self operator++(int) {       Self tmp = *this;       ++(*this);       return tmp;     }     Self operator--() {       (void)((!!((Index == 0 || Index - 1 <= SI->getNumCases()) &&                  "Index out the number of cases.")) ||              (_wassert(L"(Index == 0 || Index-1 <= SI->getNumCases()) && "                        L"\"Index out the number of cases.\"",                        L"..\\include\\llvm/IR/Instructions.h", 2558),               0));       --Index;       return *this;     }     Self operator--(int) {       Self tmp = *this;       --(*this);       return tmp;     }     bool operator==(const Self &RHS) const {       (void)((!!(RHS.SI == SI && "Incompatible operators.")) ||              (_wassert(L"RHS.SI == SI && \"Incompatible operators.\"",                        L"..\\include\\llvm/IR/Instructions.h", 2568),               0));       return RHS.Index == Index;     }     bool operator!=(const Self &RHS) const {       (void)((!!(RHS.SI == SI && "Incompatible operators.")) ||              (_wassert(L"RHS.SI == SI && \"Incompatible operators.\"",                        L"..\\include\\llvm/IR/Instructions.h", 2572),               0));       return RHS.Index != Index;     }   };
   typedef CaseIteratorT<const SwitchInst, const ConstantInt, const BasicBlock>       ConstCaseIt;
   class CaseIt : public CaseIteratorT<SwitchInst, ConstantInt, BasicBlock> {     typedef CaseIteratorT<SwitchInst, ConstantInt, BasicBlock> ParentTy;    public:     CaseIt(const ParentTy &Src) : ParentTy(Src) {}     CaseIt(SwitchInst *SI, unsigned CaseNum) : ParentTy(SI, CaseNum) {}     void setValue(ConstantInt *V) {       (void)((!!(Index < SI->getNumCases() &&                  "Index out the number of cases.")) ||              (_wassert(L"Index < SI->getNumCases() && \"Index out the number "                        L"of cases.\"",                        L"..\\include\\llvm/IR/Instructions.h", 2591),               0));       SI->setOperand(2 + Index * 2, reinterpret_cast<Value *>(V));     }     void setSuccessor(BasicBlock *S) {       SI->setSuccessor(getSuccessorIndex(), S);     }   };
  public:   inline Value *getOperand(unsigned) const;
   inline void setOperand(unsigned, Value *);
   inline op_iterator op_begin();
   template <int>   inline const Use &Op() const;
  public:   inline unsigned getNumOperands() const;
   Value *getCondition() const { return getOperand(0); }
   void setDefaultDest(BasicBlock *DefaultCase) {     setOperand(1, reinterpret_cast<Value *>(DefaultCase));   }
   unsigned getNumCases() const { return getNumOperands() / 2 - 1; }
   CaseIt case_begin() { return CaseIt(this, 0); }
   ConstCaseIt case_begin() const { return ConstCaseIt(this, 0); }
   CaseIt case_end() { return CaseIt(this, getNumCases()); }
   virtual void setSuccessorV(unsigned idx, BasicBlock *B);
 };
    template <> struct OperandTraits<SwitchInst> : public HungoffOperandTraits<2> {
};
    SwitchInst::op_iterator SwitchInst::op_begin() {
 }
    Value *SwitchInst::getOperand(unsigned i_nocapture) const {
   (void)((!!(i_nocapture < OperandTraits<SwitchInst>::operands(this) &&              "getOperand() out of range!")) ||          (_wassert(L"i_nocapture < OperandTraits<SwitchInst>::operands(this) "                    L"&& \"getOperand() out of range!\"",                    L"..\\include\\llvm/IR/Instructions.h", 2739),           0));
 }
    void SwitchInst::setOperand(unsigned i_nocapture, Value *Val_nocapture) {
   OperandTraits<SwitchInst>::op_begin(this)[i_nocapture] = Val_nocapture;
 }
    template <int Idx_nocapture> const Use &SwitchInst::Op() const {
   return this->OpFrom<Idx_nocapture>(this);
 }
    class IndirectBrInst : public TerminatorInst {
  public:   inline Value *getOperand(unsigned) const;
   inline void setOperand(unsigned, Value *);
   inline op_iterator op_begin();
 };
    template <> struct OperandTraits<IndirectBrInst> : public HungoffOperandTraits<1> {
};
    IndirectBrInst::op_iterator IndirectBrInst::op_begin() {
   return OperandTraits<IndirectBrInst>::op_begin(this);
   return OperandTraits<IndirectBrInst>::op_end(this);
 }
    Value *IndirectBrInst::getOperand(unsigned i_nocapture) const {
 }
    void IndirectBrInst::setOperand(unsigned i_nocapture, Value *Val_nocapture) {
   (void)((!!(i_nocapture < OperandTraits<IndirectBrInst>::operands(this) &&              "setOperand() out of range!")) ||          (_wassert(L"i_nocapture < "                    L"OperandTraits<IndirectBrInst>::operands(this) && "                    L"\"setOperand() out of range!\"",                    L"..\\include\\llvm/IR/Instructions.h", 2837),           0));
 }
    class InvokeInst : public TerminatorInst {
   void init(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,             ArrayRef<Value *> Args, const Twine &NameStr);
   inline InvokeInst(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,                     ArrayRef<Value *> Args, unsigned Values,                     const Twine &NameStr, Instruction *InsertBefore);
  public:   inline Value *getOperand(unsigned) const;
   inline void setOperand(unsigned, Value *);
   void setInstructionSubclassData(unsigned short D) {     Instruction::setInstructionSubclassData(D);   }
 };
    template <> struct OperandTraits<InvokeInst> : public VariadicOperandTraits<InvokeInst, 3> {
 };
    InvokeInst::InvokeInst(Value *Func, BasicBlock *IfNormal,                        BasicBlock *IfException, ArrayRef<Value *> Args,                        unsigned Values, const Twine &NameStr,                        Instruction *InsertBefore)     : TerminatorInst(cast<FunctionType>(cast<PointerType>(Func->getType())                                             ->getElementType())                          ->getReturnType(),                      Instruction::Invoke,                      OperandTraits<InvokeInst>::op_end(this) - Values, Values,                      InsertBefore) {
 }
    Value *InvokeInst::getOperand(unsigned i_nocapture) const {
   return cast_or_null<Value>(OperandTraits<InvokeInst>::op_begin(       const_cast<InvokeInst *>(this))[i_nocapture].get());
 }
    class ResumeInst : public TerminatorInst {
  public:   inline Value *getOperand(unsigned) const;
   inline void setOperand(unsigned, Value *);
   inline op_iterator op_begin();
  protected:   template <int>   inline Use &Op();
   template <int>   inline const Use &Op() const;
 };
    template <> struct OperandTraits<ResumeInst> : public FixedNumOperandTraits<ResumeInst, 1> {
 };
    ResumeInst::op_iterator ResumeInst::op_begin() {
   return OperandTraits<ResumeInst>::op_begin(this);
 }
    Value *ResumeInst::getOperand(unsigned i_nocapture) const {
   (void)((!!(i_nocapture < OperandTraits<ResumeInst>::operands(this) &&              "getOperand() out of range!")) ||          (_wassert(L"i_nocapture < OperandTraits<ResumeInst>::operands(this) "                    L"&& \"getOperand() out of range!\"",                    L"..\\include\\llvm/IR/Instructions.h", 3137),           0));
   return cast_or_null<Value>(OperandTraits<ResumeInst>::op_begin(       const_cast<ResumeInst *>(this))[i_nocapture].get());
 }
    void ResumeInst::setOperand(unsigned i_nocapture, Value *Val_nocapture) {
   (void)((!!(i_nocapture < OperandTraits<ResumeInst>::operands(this) &&              "setOperand() out of range!")) ||          (_wassert(L"i_nocapture < OperandTraits<ResumeInst>::operands(this) "                    L"&& \"setOperand() out of range!\"",                    L"..\\include\\llvm/IR/Instructions.h", 3137),           0));
 }
    template <int Idx_nocapture> Use &ResumeInst::Op() {
   virtual void setSuccessorV(unsigned idx, BasicBlock *B);
 };
    class TruncInst : public CastInst {
 };
    template <class GraphType> struct Inverse {
   const GraphType &Graph;
 };
    template <class T> struct GraphTraits<Inverse<Inverse<T> > > {
   typedef typename GraphTraits<T>::NodeType NodeType;
   typedef typename GraphTraits<T>::ChildIteratorType ChildIteratorType;
   static NodeType *getEntryNode(Inverse<Inverse<T> > *G) {     return GraphTraits<T>::getEntryNode(G->Graph.Graph);   }
   static ChildIteratorType child_end(NodeType *N) {     return GraphTraits<T>::child_end(N);   }
 };
    }
    namespace std {
    template <class _Kty, class _Pr, class _Alloc, bool _Mfl> class _Tset_traits {
 };
    template <class _Kty, class _Pr = less<_Kty>, class _Alloc = allocator<_Kty> > class set : public _Tree<_Tset_traits<_Kty, _Pr, _Alloc, false> > {
 };
    template <class _Kty, class _Pr, class _Alloc> inline void swap(set<_Kty, _Pr, _Alloc> &_Left,                  set<_Kty, _Pr, _Alloc> &_Right) {
 }
    template <class _Kty, class _Pr = less<_Kty>, class _Alloc = allocator<_Kty> > class multiset : public _Tree<_Tset_traits<_Kty, _Pr, _Alloc, true> > {
 };
    template <class _Kty, class _Pr, class _Alloc> inline void swap(multiset<_Kty, _Pr, _Alloc> &_Left,                  multiset<_Kty, _Pr, _Alloc> &_Right) {
 }
    }
    namespace llvm {
    template <class SetType, bool External> class df_iterator_storage {
  public:   SetType Visited;
 };
    template <class SetType> class df_iterator_storage<SetType, true> {
  public:   df_iterator_storage(SetType &VSet) : Visited(VSet) {}
   SetType &Visited;
 };
    template <class GraphT, class SetType = llvm::SmallPtrSet<                             typename GraphTraits<GraphT>::NodeType *, 8>,           bool ExtStorage = false, class GT = GraphTraits<GraphT> > class df_iterator : public std::iterator<std::forward_iterator_tag,                                          typename GT::NodeType, ptrdiff_t>,                     public df_iterator_storage<SetType, ExtStorage> {
   typedef std::iterator<std::forward_iterator_tag, typename GT::NodeType,                         ptrdiff_t> super;
   typedef typename GT::NodeType NodeType;
   inline void toNext() {     do {       std::pair<PointerIntTy, ChildItTy> &Top = VisitStack.back();       NodeType *Node = Top.first.getPointer();       ChildItTy &It = Top.second;       if (!Top.first.getInt()) {         It = GT::child_begin(Node);         Top.first.setInt(1);       }       while (It != GT::child_end(Node)) {         NodeType *Next = *It++;         if (Next && !this->Visited.count(Next)) {           this->Visited.insert(Next);           VisitStack.push_back(               std::make_pair(PointerIntTy(Next, 0), GT::child_begin(Next)));           return;         }       }       VisitStack.pop_back();     } while (!VisitStack.empty());   }
  public:   typedef typename super::pointer pointer;
   typedef df_iterator<GraphT, SetType, ExtStorage, GT> _Self;
   static inline _Self begin(const GraphT &G) {     return _Self(GT::getEntryNode(G));   }
   static inline _Self end(const GraphT &G) { return _Self(); }
   NodeType *getPath(unsigned n) const {     return VisitStack[n].first.getPointer();   }
 };
    template <class T> df_iterator<T> df_begin(const T &G) {
   return df_iterator<T>::begin(G);
 }
    template <class T> df_iterator<T> df_end(const T &G) {
   return df_iterator<T>::end(G);
 }
    template <class T, class SetTy = std::set<typename GraphTraits<T>::NodeType *> > struct df_ext_iterator : public df_iterator<T, SetTy, true> {
   df_ext_iterator(const df_iterator<T, SetTy, true> &V)       : df_iterator<T, SetTy, true>(V) {}
 };
    template <class T, class SetTy> df_ext_iterator<T, SetTy> df_ext_begin(const T &G, SetTy &S) {
   return df_ext_iterator<T, SetTy>::begin(G, S);
 }
    template <class T, class SetTy = llvm::SmallPtrSet<                        typename GraphTraits<T>::NodeType *, 8>,           bool External = false> struct idf_iterator : public df_iterator<Inverse<T>, SetTy, External> {
   idf_iterator(const df_iterator<Inverse<T>, SetTy, External> &V)       : df_iterator<Inverse<T>, SetTy, External>(V) {}
 };
    template <class T> idf_iterator<T> idf_begin(const T &G) {
   return idf_iterator<T>::begin(Inverse<T>(G));
 }
    template <class T, class SetTy = std::set<typename GraphTraits<T>::NodeType *> > struct idf_ext_iterator : public idf_iterator<T, SetTy, true> {
 };
    template <class T, class SetTy> idf_ext_iterator<T, SetTy> idf_ext_begin(const T &G, SetTy &S) {
   return idf_ext_iterator<T, SetTy>::begin(Inverse<T>(G), S);
 }
    class Argument : public Value, public ilist_node<Argument> {
   virtual void anchor();
   static inline bool classof(const Value *V) {     return V->getValueID() == ArgumentVal;   }
 };
    template <typename NodeTy> class ilist_iterator;
    template <typename NodeTy> struct ilist_nextprev_traits {
   static NodeTy *getPrev(NodeTy *N) { return N->getPrev(); }
   static NodeTy *getNext(NodeTy *N) { return N->getNext(); }
   static void setPrev(NodeTy *N, NodeTy *Prev) { N->setPrev(Prev); }
   static void setNext(NodeTy *N, NodeTy *Next) { N->setNext(Next); }
 };
    template <typename NodeTy> struct ilist_sentinel_traits {
   static NodeTy *createSentinel() { return new NodeTy(); }
 };
    template <typename NodeTy> struct ilist_node_traits {
   void transferNodesFromList(ilist_node_traits &, ilist_iterator<NodeTy>,                              ilist_iterator<NodeTy>) {}
 };
    template <typename NodeTy> struct ilist_default_traits : public ilist_nextprev_traits<NodeTy>,                               public ilist_sentinel_traits<NodeTy>,                               public ilist_node_traits<NodeTy> {
};
    template <typename NodeTy> class ilist_iterator     : public std::iterator<std::bidirectional_iterator_tag, NodeTy, ptrdiff_t> {
  public:   typedef ilist_traits<NodeTy> Traits;
   typedef std::iterator<std::bidirectional_iterator_tag, NodeTy, ptrdiff_t>       super;
   typedef typename super::difference_type difference_type;
   typedef typename super::pointer pointer;
   typedef typename super::reference reference;
  private:   pointer NodePtr;
   template <class T>   void operator-(T) const;
  public:   ilist_iterator(pointer NP) : NodePtr(NP) {}
   operator pointer() const { return NodePtr; }
   reference operator*() const { return *NodePtr; }
   ilist_iterator &operator++() {     NodePtr = Traits::getNext(NodePtr);     return *this;   }
   ilist_iterator operator--(int) {     ilist_iterator tmp = *this;     --*this;     return tmp;   }
   ilist_iterator operator++(int) {     ilist_iterator tmp = *this;     ++*this;     return tmp;   }
   pointer getNodePtrUnchecked() const { return NodePtr; }
 };
    template <typename T> void operator-(int, ilist_iterator<T>) = delete;
    template <typename NodeTy> struct simplify_type<ilist_iterator<NodeTy> > {
   typedef NodeTy *SimpleType;
 };
    template <typename NodeTy, typename Traits = ilist_traits<NodeTy> > class iplist : public Traits {
   mutable NodeTy *Head;
   NodeTy *getTail() { return this->ensureHead(Head); }
   const NodeTy *getTail() const { return this->ensureHead(Head); }
   void setTail(NodeTy *N) const { this->noteHead(Head, N); }
   void CreateLazySentinel() const { this->ensureHead(Head); }
   static bool op_less(NodeTy &L, NodeTy &R) { return L < R; }
  public:   typedef NodeTy *pointer;
   typedef NodeTy value_type;
   typedef ilist_iterator<NodeTy> iterator;
   typedef ilist_iterator<const NodeTy> const_iterator;
   typedef size_t size_type;
   typedef ptrdiff_t difference_type;
   typedef std::reverse_iterator<iterator> reverse_iterator;
   iplist() : Head(this->provideInitialHead()) {}
   iterator begin() {     CreateLazySentinel();     return iterator(Head);   }
   const_iterator begin() const {     CreateLazySentinel();     return const_iterator(Head);   }
   iterator end() {     CreateLazySentinel();     return iterator(getTail());   }
   const_iterator end() const {     CreateLazySentinel();     return const_iterator(getTail());   }
   reverse_iterator rbegin() { return reverse_iterator(end()); }
  private:   void transfer(iterator position, iplist &L2, iterator first, iterator last) {     (void)((!!(first != last && "Should be checked by callers")) ||            (_wassert(L"first != last && \"Should be checked by callers\"",                      L"..\\include\\llvm/ADT/ilist.h", 487),             0));     (void)((!!(position != first &&                "Insertion point can't be one of the transferred nodes")) ||            (_wassert(L"position != first && \"Insertion point can't be one of "                      L"the transferred nodes\"",                      L"..\\include\\llvm/ADT/ilist.h", 491),             0));     if (position != last) {       NodeTy *ThisSentinel = getTail();       setTail(0);       NodeTy *L2Sentinel = L2.getTail();       L2.setTail(0);       NodeTy *First = &*first, *Prev = this->getPrev(First);       NodeTy *Next = last.getNodePtrUnchecked(), *Last = this->getPrev(Next);       if (Prev)         this->setNext(Prev, Next);       else         L2.Head = Next;       this->setPrev(Next, Prev);       NodeTy *PosNext = position.getNodePtrUnchecked();       NodeTy *PosPrev = this->getPrev(PosNext);       if (PosPrev)         this->setNext(PosPrev, First);       else         Head = First;       this->setPrev(First, PosPrev);       this->setNext(Last, PosNext);       this->setPrev(PosNext, Last);       this->transferNodesFromList(L2, First, PosNext);       L2.setTail(L2Sentinel);       setTail(ThisSentinel);     }   }
  public:   size_type __attribute__((__warn_unused_result__)) size() const {     if (Head == 0) return 0;     return std::distance(begin(), end());   }
   void splice(iterator where, iplist &L2, iterator first) {     iterator last = first;     ++last;     if (where == first || where == last) return;     transfer(where, L2, first, last);   }
   void splice(iterator where, iplist &L2, iterator first, iterator last) {     if (first != last) transfer(where, L2, first, last);   }
 };
    }
    namespace llvm {
    template <typename Ty> struct ilist_traits;
    template <typename ValueSubClass, typename ItemParentClass> class SymbolTableListTraits : public ilist_default_traits<ValueSubClass> {
 };
    }
    namespace llvm {
    class BlockAddress;
    template <> struct ilist_traits<Instruction> : public SymbolTableListTraits<Instruction,                                                                 BasicBlock> {
   Instruction *createSentinel() const {     return static_cast<Instruction *>(&Sentinel);   }
   Instruction *ensureHead(Instruction *) const { return createSentinel(); }
   static void noteHead(Instruction *, Instruction *) {}
  private:   mutable ilist_half_node<Instruction> Sentinel;
 };
    class BasicBlock : public Value, public ilist_node<BasicBlock> {
   friend class BlockAddress;
  public:   typedef iplist<Instruction> InstListType;
  private:   InstListType InstList;
   Function *Parent;
  public:   LLVMContext &getContext() const;
   typedef InstListType::iterator iterator;
   typedef InstListType::const_iterator const_iterator;
   Function *getParent() { return Parent; }
   TerminatorInst *getTerminator();
   const TerminatorInst *getTerminator() const;
   inline iterator begin() { return InstList.begin(); }
   inline const_iterator begin() const { return InstList.begin(); }
   inline iterator end() { return InstList.end(); }
 };
    inline BasicBlock *unwrap(LLVMBasicBlockRef P) {
 }
    }
    namespace llvm {
    class Constant : public User {
   void removeDeadConstantUsers() const;
 };
    class Module;
    class GlobalValue : public Constant {
  public:   enum LinkageTypes {     ExternalLinkage = 0,     AvailableExternallyLinkage,     LinkOnceAnyLinkage,     LinkOnceODRLinkage,     LinkOnceODRAutoHideLinkage,     WeakAnyLinkage,     WeakODRLinkage,     AppendingLinkage,     InternalLinkage,     PrivateLinkage,     LinkerPrivateLinkage,     LinkerPrivateWeakLinkage,     DLLImportLinkage,     DLLExportLinkage,     ExternalWeakLinkage,     CommonLinkage   };
   enum VisibilityTypes {     DefaultVisibility = 0,     HiddenVisibility,     ProtectedVisibility   };
 };
    class LLVMContext;
    template <> struct ilist_traits<BasicBlock> : public SymbolTableListTraits<BasicBlock,                                                                Function> {
   BasicBlock *createSentinel() const {     return static_cast<BasicBlock *>(&Sentinel);   }
   BasicBlock *ensureHead(BasicBlock *) const { return createSentinel(); }
   static void noteHead(BasicBlock *, BasicBlock *) {}
   static ValueSymbolTable *getSymTab(Function *ItemParent);
  private:   mutable ilist_half_node<BasicBlock> Sentinel;
 };
    template <> struct ilist_traits<Argument> : public SymbolTableListTraits<Argument,                                                              Function> {
   Argument *createSentinel() const {     return static_cast<Argument *>(&Sentinel);   }
   static ValueSymbolTable *getSymTab(Function *ItemParent);
  private:   mutable ilist_half_node<Argument> Sentinel;
 };
    class Function : public GlobalValue, public ilist_node<Function> {
  public:   typedef iplist<Argument> ArgumentListType;
   typedef iplist<BasicBlock> BasicBlockListType;
   typedef BasicBlockListType::iterator iterator;
   typedef BasicBlockListType::const_iterator const_iterator;
   typedef ArgumentListType::const_iterator const_arg_iterator;
  private:   BasicBlockListType BasicBlocks;
   ValueSymbolTable *SymTab;
   AttributeSet AttributeSets;
   Function(FunctionType *Ty, LinkageTypes Linkage, const Twine &N = "",            Module *M = 0);
  public:   static Function *Create(FunctionType *Ty, LinkageTypes Linkage,                           const Twine &N = "", Module *M = 0) {     return new (0) Function(Ty, Linkage, N, M);   }
   AttributeSet getAttributes() const { return AttributeSets; }
   const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; }
   BasicBlockListType &getBasicBlockList() { return BasicBlocks; }
   iterator end() { return BasicBlocks.end(); }
   const_iterator end() const { return BasicBlocks.end(); }
 };
    inline ValueSymbolTable *ilist_traits<BasicBlock>::getSymTab(Function *F) {
 }
    }
    namespace llvm {
    class PMStack;
    class AnalysisResolver;
    class PMDataManager;
    typedef const void *AnalysisID;
    enum PassManagerType {
   PMT_Unknown = 0,   PMT_ModulePassManager = 1,   PMT_CallGraphPassManager,   PMT_FunctionPassManager,   PMT_LoopPassManager,   PMT_RegionPassManager,   PMT_BasicBlockPassManager,   PMT_Last };
    enum PassKind {
   PT_BasicBlock,   PT_Region,   PT_Loop,   PT_Function,   PT_CallGraphSCC,   PT_Module,   PT_PassManager };
    class Pass {
   AnalysisResolver *Resolver;
   const void *PassID;
   PassKind Kind;
   void operator=(const Pass &) = delete;
  public:   explicit Pass(PassKind K, char &pid) : Resolver(0), PassID(&pid), Kind(K) {}
   virtual ~Pass();
   virtual bool doInitialization(Module &) { return false; }
   template <typename AnalysisType>   AnalysisType *getAnalysisIfAvailable() const;
   bool mustPreserveAnalysisID(char &AID) const;
   template <typename AnalysisType>   AnalysisType &getAnalysis() const;
   template <typename AnalysisType>   AnalysisType &getAnalysis(Function &F);
   template <typename AnalysisType>   AnalysisType &getAnalysisID(AnalysisID PI) const;
 };
    class ModulePass : public Pass {
 };
    class ImmutablePass : public ModulePass {
  public:   virtual void initializePass();
 };
    class FunctionPass : public Pass {
 };
    extern bool TimePassesIsEnabled;
    class PassRegistry;
    void initializeCore(PassRegistry &);
    void initializeLoopUnswitchPass(PassRegistry &);
    void initializeLoopIdiomRecognizePass(PassRegistry &);
    class PassRegistry {
   mutable void *pImpl;
  public:   PassRegistry() : pImpl(0) {}
   ~PassRegistry();
   static PassRegistry *getPassRegistry();
 };
    inline PassRegistry *unwrap(LLVMPassRegistryRef P) {
   return reinterpret_cast<PassRegistry *>(P);
 }
    template <typename T> inline T *unwrap(LLVMPassRegistryRef P) {
 }
    }
    namespace llvm {
    class AnalysisUsage {
  public:   typedef SmallVector<AnalysisID, 32> VectorType;
  private:   VectorType Required, RequiredTransitive, Preserved;
   const VectorType &getPreservedSet() const { return Preserved; }
 };
    class AnalysisResolver {
  private:   AnalysisResolver() = delete;
 };
    template <typename AnalysisType> AnalysisType *Pass::getAnalysisIfAvailable() const {
   (void)((!!(Resolver && "Pass not resident in a PassManager object!")) ||          (_wassert(               L"Resolver && \"Pass not resident in a PassManager object!\"",               L"..\\include\\llvm/PassAnalysisSupport.h", 180),           0));
 }
    template <typename AnalysisType> AnalysisType &Pass::getAnalysis() const {
   (void)((!!(Resolver &&              "Pass has not been inserted into a PassManager object!")) ||          (_wassert(L"Resolver && \"Pass has not been inserted into a "                    L"PassManager object!\"",                    L"..\\include\\llvm/PassAnalysisSupport.h", 200),           0));
 }
    template <typename AnalysisType> AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
   return *(AnalysisType *)ResultPass->getAdjustedAnalysisPointer(PI);
 }
    template <typename AnalysisType> AnalysisType &Pass::getAnalysis(Function &F) {
 }
    }
    namespace llvm {
    template <class Ptr, class USE_iterator> class PredIterator : public std::iterator<std::forward_iterator_tag, Ptr,                                           ptrdiff_t, Ptr *, Ptr *> {
   typedef std::iterator<std::forward_iterator_tag, Ptr, ptrdiff_t, Ptr *, Ptr *>       super;
   typedef PredIterator<Ptr, USE_iterator> Self;
   USE_iterator It;
   inline void advancePastNonTerminators() {     while (!It.atEnd() && !isa<TerminatorInst>(*It)) ++It;   }
  public:   typedef typename super::pointer pointer;
   typedef typename super::reference reference;
   PredIterator() {}
   explicit inline PredIterator(Ptr *bb) : It(bb->use_begin()) {     advancePastNonTerminators();   }
   inline PredIterator(Ptr *bb, bool) : It(bb->use_end()) {}
   inline bool operator==(const Self &x) const { return It == x.It; }
   inline reference operator*() const {     (void)((!!(!It.atEnd() && "pred_iterator out of range!")) ||            (_wassert(L"!It.atEnd() && \"pred_iterator out of range!\"",                      L"..\\include\\llvm/Support/CFG.h", 56),             0));     return cast<TerminatorInst>(*It)->getParent();   }
   inline pointer *operator->() const { return &operator*(); }
 };
    typedef PredIterator<BasicBlock, Value::use_iterator> pred_iterator;
    typedef PredIterator<const BasicBlock, Value::const_use_iterator>     const_pred_iterator;
    inline pred_iterator pred_begin(BasicBlock *BB) {
 return pred_iterator(BB);
 }
    inline pred_iterator pred_end(BasicBlock *BB) {
   return pred_iterator(BB, true);
 }
    template <class Term_, class BB_> class SuccIterator : public std::iterator<std::bidirectional_iterator_tag, BB_,                                           ptrdiff_t, BB_ *, BB_ *> {
   const Term_ Term;
   unsigned idx;
   typedef std::iterator<std::bidirectional_iterator_tag, BB_, ptrdiff_t, BB_ *,                         BB_ *> super;
   typedef SuccIterator<Term_, BB_> Self;
   inline bool index_is_valid(int idx) {     return idx >= 0 && (unsigned)idx < Term->getNumSuccessors();   }
  public:   typedef typename super::pointer pointer;
   inline const Self &operator=(const Self &I) {     (void)((!!(Term == I.Term &&                "Cannot assign iterators to two different blocks!")) ||            (_wassert(L"Term == I.Term &&\"Cannot assign iterators to two "                      L"different blocks!\"",                      L"..\\include\\llvm/Support/CFG.h", 137),             0));     idx = I.idx;     return *this;   }
   unsigned getSuccessorIndex() const { return idx; }
   inline BB_ *getSource() {     (void)((!!(Term && "Source not available, if basic block was malformed")) ||            (_wassert(L"Term && \"Source not available, if basic block was "                      L"malformed\"",                      L"..\\include\\llvm/Support/CFG.h", 221),             0));     return Term->getParent();   }
 };
    typedef SuccIterator<TerminatorInst *, BasicBlock> succ_iterator;
    typedef SuccIterator<const TerminatorInst *, const BasicBlock>     succ_const_iterator;
    inline succ_iterator succ_begin(BasicBlock *BB) {
 }
    inline succ_const_iterator succ_end(const BasicBlock *BB) {
 }
    template <typename T, typename U> struct isPodLike<SuccIterator<T, U> > {
   static const bool value = isPodLike<T>::value;
 };
    template <> struct GraphTraits<BasicBlock *> {
   typedef BasicBlock NodeType;
 };
    template <> struct GraphTraits<const BasicBlock *> {
   typedef const BasicBlock NodeType;
   typedef succ_const_iterator ChildIteratorType;
   static NodeType *getEntryNode(const BasicBlock *BB) { return BB; }
   static inline ChildIteratorType child_end(NodeType *N) { return succ_end(N); }
 };
    template <> struct GraphTraits<Inverse<BasicBlock *> > {
 };
    }
    namespace llvm {
    template <class T> class IntrusiveRefCntPtr;
    template <class Derived> class RefCountedBase {
 };
    template <unsigned InternalLen> class SmallString : public SmallVector<char, InternalLen> {
 };
    }
    namespace llvm {
    namespace sys {
 class TimeValue {  public:   static const TimeValue MinTime;   static const TimeValue MaxTime;   static const TimeValue ZeroTime;   static const TimeValue PosixZeroTime;   static const TimeValue Win32ZeroTime;  public:   typedef int64_t SecondsType;   typedef int32_t NanoSecondsType;   enum TimeConversions {     NANOSECONDS_PER_SECOND = 1000000000,     MICROSECONDS_PER_SECOND = 1000000,     MILLISECONDS_PER_SECOND = 1000,     NANOSECONDS_PER_MICROSECOND = 1000,     NANOSECONDS_PER_MILLISECOND = 1000000,     NANOSECONDS_PER_POSIX_TICK = 100,     NANOSECONDS_PER_WIN32_TICK = 100   };  public:   TimeValue() : seconds_(0), nanos_(0) {}   explicit TimeValue(SecondsType seconds, NanoSecondsType nanos = 0)       : seconds_(seconds), nanos_(nanos) {     this->normalize();   }   explicit TimeValue(double new_time) : seconds_(0), nanos_(0) {     SecondsType integer_part = static_cast<SecondsType>(new_time);     seconds_ = integer_part;     nanos_ = static_cast<NanoSecondsType>(         (new_time - static_cast<double>(integer_part)) *         NANOSECONDS_PER_SECOND);     this->normalize();   }   static TimeValue now();  public:   TimeValue &operator+=(const TimeValue &that) {     this->seconds_ += that.seconds_;     this->nanos_ += that.nanos_;     this->normalize();     return *this;   }   TimeValue &operator-=(const TimeValue &that) {     this->seconds_ -= that.seconds_;     this->nanos_ -= that.nanos_;     this->normalize();     return *this;   }   int operator<(const TimeValue &that) const { return that > *this; }   int operator>(const TimeValue &that) const {     if (this->seconds_ > that.seconds_) {       return 1;     } else if (this->seconds_ == that.seconds_) {       if (this->nanos_ > that.nanos_) return 1;     }     return 0;   }   int operator<=(const TimeValue &that) const { return that >= *this; }   int operator>=(const TimeValue &that) const {     if (this->seconds_ > that.seconds_) {       return 1;     } else if (this->seconds_ == that.seconds_) {       if (this->nanos_ >= that.nanos_) return 1;     }     return 0;   }   int operator==(const TimeValue &that) const {     return (this->seconds_ == that.seconds_) && (this->nanos_ == that.nanos_);   }   int operator!=(const TimeValue &that) const { return !(*this == that); }   friend TimeValue operator+(const TimeValue &tv1, const TimeValue &tv2);   friend TimeValue operator-(const TimeValue &tv1, const TimeValue &tv2);  public:   SecondsType seconds() const { return seconds_; }   NanoSecondsType nanoseconds() const { return nanos_; }   uint32_t microseconds() const { return nanos_ / NANOSECONDS_PER_MICROSECOND; }   uint32_t milliseconds() const { return nanos_ / NANOSECONDS_PER_MILLISECOND; }   uint64_t usec() const {     return seconds_ * MICROSECONDS_PER_SECOND +            (nanos_ / NANOSECONDS_PER_MICROSECOND);   }   uint64_t msec() const {     return seconds_ * MILLISECONDS_PER_SECOND +            (nanos_ / NANOSECONDS_PER_MILLISECOND);   }   uint64_t toPosixTime() const {     uint64_t result = seconds_ - PosixZeroTimeSeconds;     result += nanos_ / NANOSECONDS_PER_POSIX_TICK;     return result;   }   uint64_t toEpochTime() const { return seconds_ - PosixZeroTimeSeconds; }   uint64_t toWin32Time() const {     uint64_t result = (uint64_t)10000000 * (seconds_ - Win32ZeroTimeSeconds);     result += nanos_ / NANOSECONDS_PER_WIN32_TICK;     return result;   }   void getTimespecTime(uint64_t &seconds, uint32_t &nanos) const {     seconds = seconds_ - PosixZeroTimeSeconds;     nanos = nanos_;   }   std::string str() const;  public:   void seconds(SecondsType sec) {     this->seconds_ = sec;     this->normalize();   }   void nanoseconds(NanoSecondsType nanos) {     this->nanos_ = nanos;     this->normalize();   }   void microseconds(int32_t micros) {     this->nanos_ = micros * NANOSECONDS_PER_MICROSECOND;     this->normalize();   }   void milliseconds(int32_t millis) {     this->nanos_ = millis * NANOSECONDS_PER_MILLISECOND;     this->normalize();   }   void usec(int64_t microseconds) {     this->seconds_ = microseconds / MICROSECONDS_PER_SECOND;     this->nanos_ = NanoSecondsType(microseconds % MICROSECONDS_PER_SECOND) *                    NANOSECONDS_PER_MICROSECOND;     this->normalize();   }   void msec(int64_t milliseconds) {     this->seconds_ = milliseconds / MILLISECONDS_PER_SECOND;     this->nanos_ = NanoSecondsType(milliseconds % MILLISECONDS_PER_SECOND) *                    NANOSECONDS_PER_MILLISECOND;     this->normalize();   }   void fromEpochTime(SecondsType seconds) {     seconds_ = seconds + PosixZeroTimeSeconds;     nanos_ = 0;     this->normalize();   }   void fromWin32Time(uint64_t win32Time) {     this->seconds_ = win32Time / 10000000 + Win32ZeroTimeSeconds;     this->nanos_ = NanoSecondsType(win32Time % 10000000) * 100;   }  private:   void normalize();  private:   SecondsType seconds_;   NanoSecondsType nanos_;   static const SecondsType PosixZeroTimeSeconds;   static const SecondsType Win32ZeroTimeSeconds; };
 inline TimeValue operator-(const TimeValue &tv1, const TimeValue &tv2) {   TimeValue difference(tv1.seconds_ - tv2.seconds_, tv1.nanos_ - tv2.nanos_);   difference.normalize();   return difference; }
 }
    }
    namespace llvm {
    template <class Tp> struct is_error_code_enum : public false_type {
};
    template <class Tp> struct is_error_condition_enum : public false_type {
};
    struct errc {
   enum _ {     success = 0,     address_family_not_supported = 102,     address_in_use = 100,     address_not_available = 101,     already_connected = 113,     argument_list_too_long = 7,     argument_out_of_domain = 33,     bad_address = 14,     bad_file_descriptor = 9,     bad_message = 104,     broken_pipe = 32,     connection_aborted = 106,     connection_already_in_progress = 103,     connection_refused = 107,     connection_reset = 108,     cross_device_link = 18,     destination_address_required = 109,     device_or_resource_busy = 16,     directory_not_empty = 41,     executable_format_error = 8,     file_exists = 17,     file_too_large = 27,     filename_too_long = 38,     function_not_supported = 40,     host_unreachable = 110,     identifier_removed = 111,     illegal_byte_sequence = 42,     inappropriate_io_control_operation = 25,     interrupted = 4,     invalid_argument = 22,     invalid_seek = 29,     io_error = 5,     is_a_directory = 21,     message_size = 115,     network_down = 116,     network_reset = 117,     network_unreachable = 118,     no_buffer_space = 119,     no_child_process = 10,     no_link = 121,     no_lock_available = 39,     no_message_available = 120,     no_message = 122,     no_protocol_option = 123,     no_space_on_device = 28,     no_stream_resources = 124,     no_such_device_or_address = 6,     no_such_device = 19,     no_such_file_or_directory = 2,     no_such_process = 3,     not_a_directory = 20,     not_a_socket = 128,     not_a_stream = 125,     not_connected = 126,     not_enough_memory = 12,     not_supported = 129,     operation_canceled = 105,     operation_in_progress = 112,     operation_not_permitted = 1,     operation_not_supported = 130,     operation_would_block = 140,     owner_dead = 133,     permission_denied = 13,     protocol_error = 134,     protocol_not_supported = 135,     read_only_file_system = 30,     resource_deadlock_would_occur = 36,     resource_unavailable_try_again = 11,     result_out_of_range = 34,     state_not_recoverable = 127,     stream_timeout = 137,     text_file_busy = 139,     timed_out = 138,     too_many_files_open_in_system = 23,     too_many_files_open = 24,     too_many_links = 31,     too_many_symbolic_link_levels = 114,     value_too_large = 132,     wrong_protocol_type = 136   };
   _ v_;
   operator int() const { return v_; }
 };
    template <> struct is_error_condition_enum<errc> : true_type {
};
    class error_category {
  public:   virtual ~error_category();
   friend class _do_message;
 };
    class error_condition {
   int _val_;
   const error_category *_cat_;
   std::string message() const;
   typedef void (*unspecified_bool_type)();
   static void unspecified_bool_true() {}
   operator unspecified_bool_type() const {     return _val_ == 0 ? 0 : unspecified_bool_true;   }
 };
    class error_code {
 };
    double __cdecl _difftime64(__time64_t _Time1, __time64_t _Time2);
    __declspec(deprecated(     "This function or variable has been superceded by newer library or "     "operating system functionality. Consider using "     "SetLocalTime"     " instead. See online help for details.")) unsigned __cdecl _setsystime(struct                                                                             tm *_Tm,                                                                             unsigned                                                                                 _MilliSec);
    static __inline double __cdecl difftime(time_t _Time1, time_t _Time2) {
 }
    void __cdecl tzset(void);
    }
    namespace std {
    template <class _Mydeque> class _Deque_unchecked_const_iterator {
  public:   typedef _Deque_unchecked_const_iterator<_Mydeque> _Myiter;
 };
    template <class _Mydeque> inline _Deque_unchecked_const_iterator<_Mydeque> operator+(     typename _Deque_unchecked_const_iterator<_Mydeque>::difference_type _Off,     _Deque_unchecked_const_iterator<_Mydeque> _Next) {
   reference operator[](difference_type _Off) const { return (*(*this + _Off)); }
 };
    template <class _Mydeque> class _Deque_const_iterator : public _Iterator_base12 {
  public:   typedef _Deque_const_iterator<_Mydeque> _Myiter;
 };
    template <class _Mydeque> inline typename _Deque_const_iterator<_Mydeque>::_Unchecked_type _Unchecked(     _Deque_const_iterator<_Mydeque> _Iter) {
   return (_Iter._Unchecked());
 }
    template <class _Mydeque> class _Deque_iterator : public _Deque_const_iterator<_Mydeque> {
  public:   typedef _Deque_iterator<_Mydeque> _Myiter;
 };
    template <class _Mydeque> inline typename _Deque_iterator<_Mydeque>::_Unchecked_type _Unchecked(     _Deque_iterator<_Mydeque> _Iter) {
 }
    template <class _Value_type, class _Size_type, class _Difference_type,           class _Pointer, class _Const_pointer, class _Reference,           class _Const_reference, class _Mapptr_type> struct _Deque_iter_types {
 };
    template <class _Ty> struct _Deque_simple_types : public _Simple_types<_Ty> {
 };
    template <class _Ty, class _Alloc0> struct _Deque_base_types {
   typedef _Alloc0 _Alloc;
   typedef _Deque_base_types<_Ty, _Alloc> _Myt;
   typedef _Wrap_alloc<_Alloc> _Alty0;
   typedef typename _Alty0::template rebind<_Ty>::other _Alty;
   typedef typename _Alty::pointer _Tptr;
   typedef typename _Alty::template rebind<_Tptr>::other _Alpty;
   typedef typename _Alpty::pointer _Mapptr;
   typedef typename _If<       _Is_simple_alloc<_Alty>::value,       _Deque_simple_types<typename _Alty::value_type>,       _Deque_iter_types<           typename _Alty::value_type, typename _Alty::size_type,           typename _Alty::difference_type, typename _Alty::pointer,           typename _Alty::const_pointer, typename _Alty::reference,           typename _Alty::const_reference, _Mapptr> >::type _Val_types;
 };
    template <class _Val_types> class _Deque_val : public _Container_base12 {
   typedef typename _Val_types::size_type size_type;
   typedef typename _Val_types::difference_type difference_type;
   size_type _Mysize;
 };
    template <bool _Al_has_storage, class _Alloc_types> class _Deque_alloc : public _Deque_val<typename _Alloc_types::_Val_types> {
 };
    template <class _Ty, class _Alloc = allocator<_Ty> > class deque : public _Deque_alloc<!is_empty<_Alloc>::value,                                   _Deque_base_types<_Ty, _Alloc> > {
 };
    template <class _Ty, class _Alloc> inline void swap(deque<_Ty, _Alloc> &_Left, deque<_Ty, _Alloc> &_Right) {
 }
    template <class _Ty, class _Container = deque<_Ty> > class stack {
 };
    template <class _Ty, class _Container> inline void swap(stack<_Ty, _Container> &_Left,                  stack<_Ty, _Container> &_Right) {
 }
    }
    namespace llvm {
    class format_object_base;
    template <typename T> class SmallVectorImpl;
    class raw_ostream {
   enum BufferKind {     Unbuffered = 0,     InternalBuffer,     ExternalBuffer   }
 BufferMode;
  public:   enum Colors {     BLACK = 0,     RED,     GREEN,     YELLOW,     BLUE,     MAGENTA,     CYAN,     WHITE,     SAVEDCOLOR   };
   raw_ostream &operator<<(const std::string &Str) {     return write(Str.data(), Str.length());   }
   raw_ostream &operator<<(unsigned long N);
   raw_ostream &operator<<(long N);
   raw_ostream &operator<<(unsigned int N) {     return this->operator<<(static_cast<unsigned long>(N));   }
   raw_ostream &operator<<(int N) {     return this->operator<<(static_cast<long>(N));   }
   raw_ostream &write(const char *Ptr, size_t Size);
   raw_ostream &operator<<(const format_object_base &Fmt);
   void copy_to_buffer(const char *Ptr, size_t Size);
 };
    class raw_fd_ostream : public raw_ostream {
 };
    template <class NodeT> class DominatorBase {
 };
    template <class NodeT> class DominatorTreeBase;
    struct PostDominatorTree;
    template <class NodeT> class DomTreeNodeBase {
   NodeT *TheBB;
   DomTreeNodeBase<NodeT> *IDom;
   std::vector<DomTreeNodeBase<NodeT> *> Children;
  public:   typedef typename std::vector<DomTreeNodeBase<NodeT> *>::iterator iterator;
   typedef typename std::vector<DomTreeNodeBase<NodeT> *>::const_iterator       const_iterator;
   iterator end() { return Children.end(); }
   const_iterator begin() const { return Children.begin(); }
 };
    ;
    ;
    template <class NodeT> inline raw_ostream &operator<<(raw_ostream &o,                                const DomTreeNodeBase<NodeT> *Node) {
 ++I)     PrintDomTree<NodeT>(*I, o, Lev + 1);
 }
    typedef DomTreeNodeBase<BasicBlock> DomTreeNode;
    template <class FuncT, class N> void Calculate(DominatorTreeBase<typename GraphTraits<N>::NodeType> &DT,                FuncT &F);
    template <class NodeT> class DominatorTreeBase : public DominatorBase<NodeT> {
   bool dominates(const NodeT *A, const NodeT *B);
 };
    template <class NodeT> bool DominatorTreeBase<NodeT>::dominates(const NodeT *A, const NodeT *B) {
   if (A == B) return true;
   return dominates(getNode(const_cast<NodeT *>(A)),                    getNode(const_cast<NodeT *>(B)));
 }
    class BasicBlockEdge {
   const BasicBlock *Start;
   bool isSingleEdge() const;
 };
    class DominatorTree : public FunctionPass {
  public:   static char ID;
 };
    template <> struct GraphTraits<DomTreeNode *> {
   typedef DomTreeNode NodeType;
   typedef NodeType::iterator ChildIteratorType;
   static NodeType *getEntryNode(NodeType *N) { return N; }
   static inline ChildIteratorType child_end(NodeType *N) { return N->end(); }
   typedef df_iterator<DomTreeNode *> nodes_iterator;
   static nodes_iterator nodes_end(DomTreeNode *N) {     return df_end(getEntryNode(N));   }
 };
    template <typename ValueT, typename ValueInfoT = DenseMapInfo<ValueT> > class DenseSet {
   template <typename InputIt>   void insert(InputIt I, InputIt E) {     for (; I != E; ++I) insert(*I);   }
 };
    }
    namespace llvm {
    template <typename T> inline void RemoveFromVector(std::vector<T *> &V, T *N) {
 }
    template <class BlockT, class LoopT> class LoopBase {
   LoopT *ParentLoop;
   std::vector<LoopT *> SubLoops;
   std::vector<BlockT *> Blocks;
   const LoopBase<BlockT, LoopT> &operator=(const LoopBase<BlockT, LoopT> &) =       delete;
  public:   LoopBase() : ParentLoop(0) {}
   unsigned getLoopDepth() const {     unsigned D = 1;     for (const LoopT *CurLoop = ParentLoop; CurLoop;          CurLoop = CurLoop->ParentLoop)       ++D;     return D;   }
   BlockT *getHeader() const { return Blocks.front(); }
   LoopT *getParentLoop() const { return ParentLoop; }
   void setParentLoop(LoopT *L) { ParentLoop = L; }
   bool contains(const LoopT *L) const {     if (L == this) return true;     if (L == 0) return false;     return contains(L->getParentLoop());   }
   bool empty() const { return SubLoops.empty(); }
   const std::vector<BlockT *> &getBlocks() const { return Blocks; }
   std::vector<BlockT *> &getBlocksVector() { return Blocks; }
   typedef typename std::vector<BlockT *>::const_iterator block_iterator;
   block_iterator block_begin() const { return Blocks.begin(); }
   block_iterator block_end() const { return Blocks.end(); }
 };
    template <class BlockT, class LoopT> raw_ostream &operator<<(raw_ostream &OS, const LoopBase<BlockT, LoopT> &Loop) {
   Loop.print(OS);
 }
    class Loop : public LoopBase<BasicBlock, Loop> {
  public:   Loop() {}
   void getUniqueExitBlocks(SmallVectorImpl<BasicBlock *> &ExitBlocks) const;
   BasicBlock *getUniqueExitBlock() const;
 };
    template <class BlockT, class LoopT> class LoopInfoBase {
   DenseMap<BlockT *, LoopT *> BBMap;
   std::vector<LoopT *> TopLevelLoops;
   friend class LoopInfo;
   void operator=(const LoopInfoBase &) = delete;
   bool empty() const { return TopLevelLoops.empty(); }
   LoopT *getLoopFor(const BlockT *BB) const {     return BBMap.lookup(const_cast<BlockT *>(BB));   }
 };
    class LoopInfo : public FunctionPass {
   LoopInfoBase<BasicBlock, Loop> LI;
   bool empty() const { return LI.empty(); }
   inline Loop *getLoopFor(const BasicBlock *BB) const {     return LI.getLoopFor(BB);   }
   bool replacementPreservesLCSSAForm(Instruction *From, Value *To) {     Instruction *I = dyn_cast<Instruction>(To);     if (!I) return true;     if (I->getParent() == From->getParent()) return true;     Loop *ToLoop = getLoopFor(I->getParent());     if (!ToLoop) return true;     return ToLoop->contains(getLoopFor(From->getParent()));   }
 };
    template <> struct GraphTraits<const Loop *> {
 };
    }
    namespace llvm {
    class PrettyStackTraceEntry {
   const PrettyStackTraceEntry *NextEntry;
   PrettyStackTraceEntry(const PrettyStackTraceEntry &) = delete;
   const PrettyStackTraceEntry *getNextEntry() const { return NextEntry; }
 };
    enum PassDebuggingString {
 };
    class PMStack {
  private:   std::vector<PMDataManager *> S;
 };
    class PMTopLevelManager {
 };
    class PMDataManager {
  public:   explicit PMDataManager() : TPM(0), Depth(0) { initializeAnalysisInfo(); }
   void initializeAnalysisInfo() {     AvailableAnalysis.clear();     for (unsigned i = 0; i < PMT_Last; ++i) InheritedAnalysis[i] = 0;   }
   bool preserveHigherLevelAnalysis(Pass *P);
  protected:   PMTopLevelManager *TPM;
   SmallVector<Pass *, 16> PassVector;
   DenseMap<AnalysisID, Pass *> *InheritedAnalysis[PMT_Last];
   DenseMap<AnalysisID, Pass *> AvailableAnalysis;
   SmallVector<Pass *, 8> HigherLevelAnalysis;
   unsigned Depth;
 };
    class FPPassManager : public ModulePass, public PMDataManager {
  public:   static char ID;
   virtual PassManagerType getPassManagerType() const {     return PMT_FunctionPassManager;   }
 };
    class LPPassManager;
    class LoopPass : public Pass {
  public:   explicit LoopPass(char &pid) : Pass(PT_Loop, pid) {}
   Pass *createPrinterPass(raw_ostream &O, const std::string &Banner) const;
   virtual bool runOnLoop(Loop *L, LPPassManager &LPM) = 0;
   using llvm::Pass::doInitialization;
 };
    class LPPassManager : public FunctionPass, public PMDataManager {
  public:   static char ID;
   Loop *CurrentLoop;
 };
    class ConstantInt : public Constant {
   virtual void anchor();
  protected:   void *operator new(size_t s) { return User::operator new(s, 0); }
  public:   static ConstantInt *getTrue(LLVMContext &Context);
 };
    class ConstantArray : public Constant {
  public:   inline Constant *getOperand(unsigned) const;
   inline void setOperand(unsigned, Constant *);
   inline op_iterator op_begin();
 };
    template <> struct OperandTraits<ConstantArray> : public VariadicOperandTraits<     ConstantArray> {
};
    ConstantArray::op_iterator ConstantArray::op_begin() {
   return OperandTraits<ConstantArray>::op_begin(this);
 }
    Constant *ConstantArray::getOperand(unsigned i_nocapture) const {
   (void)((!!(i_nocapture < OperandTraits<ConstantArray>::operands(this) &&              "getOperand() out of range!")) ||          (_wassert(L"i_nocapture < "                    L"OperandTraits<ConstantArray>::operands(this) && "                    L"\"getOperand() out of range!\"",                    L"..\\include\\llvm/IR/Constants.h", 373),           0));
 }
    class ConstantExpr : public Constant {
   static Constant *getBinOpAbsorber(unsigned Opcode, Type *Ty);
  public:   inline Constant *getOperand(unsigned) const;
   inline void setOperand(unsigned, Constant *);
 };
    template <> struct OperandTraits<ConstantExpr> : public VariadicOperandTraits<ConstantExpr,                                                                   1> {
};
    Constant *ConstantExpr::getOperand(unsigned i_nocapture) const {
 }
    void ConstantExpr::setOperand(unsigned i_nocapture, Constant *Val_nocapture) {
   (void)((!!(i_nocapture < OperandTraits<ConstantExpr>::operands(this) &&              "setOperand() out of range!")) ||          (_wassert(L"i_nocapture < OperandTraits<ConstantExpr>::operands(this) "                    L"&& \"setOperand() out of range!\"",                    L"..\\include\\llvm/IR/Constants.h", 1108),           0));
 };
    }
    namespace llvm {
    class StructType;
    class StructLayout;
    enum AlignTypeEnum {
 };
    class DataLayout : public ImmutablePass {
   uint64_t getTypeSizeInBits(Type *Ty) const;
   uint64_t getTypeStoreSize(Type *Ty) const {     return (getTypeSizeInBits(Ty) + 7) / 8;   }
 };
    class StructLayout {
   StructLayout(StructType *ST, const DataLayout &DL);
 };
    inline uint64_t DataLayout::getTypeSizeInBits(Type *Ty) const {
 }
    template <typename ItTy = User::const_op_iterator> class generic_gep_type_iterator     : public std::iterator<std::forward_iterator_tag, Type *, ptrdiff_t> {
   typedef std::iterator<std::forward_iterator_tag, Type *, ptrdiff_t> super;
   ItTy OpIt;
   Type *CurTy;
   generic_gep_type_iterator() {}
  public:   static generic_gep_type_iterator begin(Type *Ty, ItTy It) {     generic_gep_type_iterator I;     I.CurTy = Ty;     I.OpIt = It;     return I;   }
   generic_gep_type_iterator operator++(int) {     generic_gep_type_iterator tmp = *this;     ++*this;     return tmp;   }
 };
    typedef generic_gep_type_iterator<> gep_type_iterator;
    inline gep_type_iterator gep_type_begin(const User *GEP) {
   return gep_type_iterator::begin(       GEP->getOperand(0)->getType()->getScalarType(), GEP->op_begin() + 1);
 };
    class MallocAllocator {
 };
    class MemSlab {
  public:   size_t Size;
 };
    class SlabAllocator {
   virtual MemSlab *Allocate(size_t Size) = 0;
   virtual void Deallocate(MemSlab *Slab) = 0;
 };
    class MallocSlabAllocator : public SlabAllocator {
   MallocAllocator Allocator;
   virtual void Deallocate(MemSlab *Slab) override;
 };
    class BumpPtrAllocator {
   BumpPtrAllocator(const BumpPtrAllocator &) = delete;
 };
    template <typename T> class SpecificBumpPtrAllocator {
   BumpPtrAllocator Allocator;
   T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
 };
    }
    namespace llvm {
    class ConstantRange {
   typedef APInt APIntMoveTy;
  public:   explicit ConstantRange(uint32_t BitWidth, bool isFullSet = true);
   void print(raw_ostream &OS) const;
   void dump() const;
 };
    inline raw_ostream &operator<<(raw_ostream &OS, const ConstantRange &CR) {
   CR.print(OS);
 }
    }
    namespace llvm {
    template <> class PointerLikeTypeTraits<ValueHandleBase **> {
  public:   static inline void *getAsVoidPointer(ValueHandleBase **P) { return P; }
   static inline ValueHandleBase **getFromVoidPointer(void *P) {     return static_cast<ValueHandleBase **>(P);   }
   enum {     NumLowBitsAvailable = 2   };
 };
    class ValueHandleBase {
  protected:   enum HandleBaseKind {     Assert,     Callback,     Tracking,     Weak   };
  private:   PointerIntPair<ValueHandleBase **, 2, HandleBaseKind> PrevPair;
   ValueHandleBase *Next;
   PointerIntPair<Value *, 2> VP;
   ValueHandleBase(const ValueHandleBase &) = delete;
  public:   explicit ValueHandleBase(HandleBaseKind Kind)       : PrevPair(0, Kind), Next(0), VP(0, 0) {}
   ValueHandleBase(HandleBaseKind Kind, Value *V)       : PrevPair(0, Kind), Next(0), VP(V, 0) {     if (isValid(VP.getPointer())) AddToUseList();   }
   ValueHandleBase(HandleBaseKind Kind, const ValueHandleBase &RHS)       : PrevPair(0, Kind), Next(0), VP(RHS.VP) {     if (isValid(VP.getPointer())) AddToExistingUseList(RHS.getPrevPtr());   }
   ~ValueHandleBase() {     if (isValid(VP.getPointer())) RemoveFromUseList();   }
   Value *operator=(Value *RHS) {     if (VP.getPointer() == RHS) return RHS;     if (isValid(VP.getPointer())) RemoveFromUseList();     VP.setPointer(RHS);     if (isValid(VP.getPointer())) AddToUseList();     return RHS;   }
  protected:   Value *getValPtr() const { return VP.getPointer(); }
   void setValPtrInt(unsigned K) { VP.setInt(K); }
   static bool isValid(Value *V) {     return V && V != DenseMapInfo<Value *>::getEmptyKey() &&            V != DenseMapInfo<Value *>::getTombstoneKey();   }
  public:   static void ValueIsDeleted(Value *V);
  private:   ValueHandleBase **getPrevPtr() const { return PrevPair.getPointer(); }
   HandleBaseKind getKind() const { return PrevPair.getInt(); }
   void AddToExistingUseList(ValueHandleBase **List);
   void AddToExistingUseListAfter(ValueHandleBase *Node);
   void AddToUseList();
   void RemoveFromUseList();
 };
    class WeakVH : public ValueHandleBase {
  public:   WeakVH() : ValueHandleBase(Weak) {}
   WeakVH(Value *P) : ValueHandleBase(Weak, P) {}
   WeakVH(const WeakVH &RHS) : ValueHandleBase(Weak, RHS) {}
   operator Value *() const { return getValPtr(); }
 };
    template <> struct simplify_type<WeakVH> {
   typedef Value *SimpleType;
   static SimpleType getSimplifiedValue(WeakVH &WVH) { return WVH; }
 };
    class CallbackVH : public ValueHandleBase {
  protected:   CallbackVH(const CallbackVH &RHS) : ValueHandleBase(Callback, RHS) {}
   virtual ~CallbackVH() {}
   void setValPtr(Value *P) { ValueHandleBase::operator=(P); }
  public:   CallbackVH() : ValueHandleBase(Callback) {}
   CallbackVH(Value *P) : ValueHandleBase(Callback, P) {}
   operator Value *() const { return getValPtr(); }
   virtual void deleted();
 };
    class LoopInfo;
    class SCEVUnknown;
    class SCEV;
    class SCEV : public FoldingSetNode {
   friend struct FoldingSetTrait<SCEV>;
   void dump() const;
 };
    template <> struct FoldingSetTrait<SCEV> : DefaultFoldingSetTrait<SCEV> {
 };
    class ScalarEvolution : public FunctionPass {
  public:   enum LoopDisposition {     LoopVariant,     LoopInvariant,     LoopComputable   };
   void forgetLoop(const Loop *L);
   SCEVUnknown *FirstUnknown;
 };
    namespace Intrinsic {
 enum ID {   not_intrinsic = 0,   aarch64_neon_saddlv,   aarch64_neon_smaxv,   aarch64_neon_sminv,   aarch64_neon_uaddlv,   aarch64_neon_umaxv,   aarch64_neon_uminv,   aarch64_neon_vacgeq,   aarch64_neon_vacgtq,   aarch64_neon_vaddds,   aarch64_neon_vadddu,   aarch64_neon_vaddv,   aarch64_neon_vmaxnm,   aarch64_neon_vmaxnmv,   aarch64_neon_vmaxv,   aarch64_neon_vminnm,   aarch64_neon_vminnmv,   aarch64_neon_vminv,   aarch64_neon_vmulx,   aarch64_neon_vpadd,   aarch64_neon_vpfadd,   aarch64_neon_vpfaddq,   aarch64_neon_vpfmaxnm,   aarch64_neon_vpfmaxnmq,   aarch64_neon_vpfminnm,   aarch64_neon_vpfminnmq,   aarch64_neon_vpmax,   aarch64_neon_vpmaxnm,   aarch64_neon_vpmaxq,   aarch64_neon_vpmin,   aarch64_neon_vpminnm,   aarch64_neon_vpminq,   aarch64_neon_vqadds,   aarch64_neon_vqaddu,   aarch64_neon_vqrshls,   aarch64_neon_vqrshlu,   aarch64_neon_vqshls,   aarch64_neon_vqshlu,   aarch64_neon_vqsubs,   aarch64_neon_vqsubu,   aarch64_neon_vrshlds,   aarch64_neon_vrshldu,   aarch64_neon_vrshrn,   aarch64_neon_vshlds,   aarch64_neon_vshldu,   aarch64_neon_vsli,   aarch64_neon_vsqrshrn,   aarch64_neon_vsqrshrun,   aarch64_neon_vsqshlu,   aarch64_neon_vsqshrn,   aarch64_neon_vsqshrun,   aarch64_neon_vsri,   aarch64_neon_vsrshr,   aarch64_neon_vsubds,   aarch64_neon_vsubdu,   aarch64_neon_vuqrshrn,   aarch64_neon_vuqshrn,   aarch64_neon_vurshr,   adjust_trampoline,   annotation,   arm_cdp,   arm_cdp2,   arm_clrex,   arm_crc32b,   arm_crc32cb,   arm_crc32ch,   arm_crc32cw,   arm_crc32h,   arm_crc32w,   arm_dmb,   arm_dsb,   arm_get_fpscr,   arm_ldrex,   arm_ldrexd,   arm_mcr,   arm_mcr2,   arm_mcrr,   arm_mcrr2,   arm_mrc,   arm_mrc2,   arm_neon_aesd,   arm_neon_aese,   arm_neon_aesimc,   arm_neon_aesmc,   arm_neon_sha1c,   arm_neon_sha1h,   arm_neon_sha1m,   arm_neon_sha1p,   arm_neon_sha1su0,   arm_neon_sha1su1,   arm_neon_sha256h,   arm_neon_sha256h2,   arm_neon_sha256su0,   arm_neon_sha256su1,   arm_neon_vabds,   arm_neon_vabdu,   arm_neon_vabs,   arm_neon_vacged,   arm_neon_vacgeq,   arm_neon_vacgtd,   arm_neon_vacgtq,   arm_neon_vbsl,   arm_neon_vcls,   arm_neon_vclz,   arm_neon_vcnt,   arm_neon_vcvtas,   arm_neon_vcvtau,   arm_neon_vcvtfp2fxs,   arm_neon_vcvtfp2fxu,   arm_neon_vcvtfp2hf,   arm_neon_vcvtfxs2fp,   arm_neon_vcvtfxu2fp,   arm_neon_vcvthf2fp,   arm_neon_vcvtms,   arm_neon_vcvtmu,   arm_neon_vcvtns,   arm_neon_vcvtnu,   arm_neon_vcvtps,   arm_neon_vcvtpu,   arm_neon_vhadds,   arm_neon_vhaddu,   arm_neon_vhsubs,   arm_neon_vhsubu,   arm_neon_vld1,   arm_neon_vld2,   arm_neon_vld2lane,   arm_neon_vld3,   arm_neon_vld3lane,   arm_neon_vld4,   arm_neon_vld4lane,   arm_neon_vmaxnm,   arm_neon_vmaxs,   arm_neon_vmaxu,   arm_neon_vminnm,   arm_neon_vmins,   arm_neon_vminu,   arm_neon_vmullp,   arm_neon_vmulls,   arm_neon_vmullu,   arm_neon_vmulp,   arm_neon_vpadals,   arm_neon_vpadalu,   arm_neon_vpadd,   arm_neon_vpaddls,   arm_neon_vpaddlu,   arm_neon_vpmaxs,   arm_neon_vpmaxu,   arm_neon_vpmins,   arm_neon_vpminu,   arm_neon_vqabs,   arm_neon_vqadds,   arm_neon_vqaddu,   arm_neon_vqdmulh,   arm_neon_vqdmull,   arm_neon_vqmovns,   arm_neon_vqmovnsu,   arm_neon_vqmovnu,   arm_neon_vqneg,   arm_neon_vqrdmulh,   arm_neon_vqrshiftns,   arm_neon_vqrshiftnsu,   arm_neon_vqrshiftnu,   arm_neon_vqrshifts,   arm_neon_vqrshiftu,   arm_neon_vqshiftns,   arm_neon_vqshiftnsu,   arm_neon_vqshiftnu,   arm_neon_vqshifts,   arm_neon_vqshiftsu,   arm_neon_vqshiftu,   arm_neon_vqsubs,   arm_neon_vqsubu,   arm_neon_vraddhn,   arm_neon_vrecpe,   arm_neon_vrecps,   arm_neon_vrhadds,   arm_neon_vrhaddu,   arm_neon_vrinta,   arm_neon_vrintm,   arm_neon_vrintn,   arm_neon_vrintp,   arm_neon_vrintx,   arm_neon_vrintz,   arm_neon_vrshiftn,   arm_neon_vrshifts,   arm_neon_vrshiftu,   arm_neon_vrsqrte,   arm_neon_vrsqrts,   arm_neon_vrsubhn,   arm_neon_vshiftins,   arm_neon_vshiftls,   arm_neon_vshiftlu,   arm_neon_vshiftn,   arm_neon_vshifts,   arm_neon_vshiftu,   arm_neon_vst1,   arm_neon_vst2,   arm_neon_vst2lane,   arm_neon_vst3,   arm_neon_vst3lane,   arm_neon_vst4,   arm_neon_vst4lane,   arm_neon_vtbl1,   arm_neon_vtbl2,   arm_neon_vtbl3,   arm_neon_vtbl4,   arm_neon_vtbx1,   arm_neon_vtbx2,   arm_neon_vtbx3,   arm_neon_vtbx4,   arm_qadd,   arm_qsub,   arm_set_fpscr,   arm_sevl,   arm_ssat,   arm_strex,   arm_strexd,   arm_thread_pointer,   arm_usat,   arm_vcvtr,   arm_vcvtru,   bswap,   ceil,   convert_from_fp16,   convert_to_fp16,   convertff,   convertfsi,   convertfui,   convertsif,   convertss,   convertsu,   convertuif,   convertus,   convertuu,   copysign,   cos,   ctlz,   ctpop,   cttz,   cuda_syncthreads,   dbg_declare,   dbg_value,   debugtrap,   donothing,   eh_dwarf_cfa,   eh_return_i32,   eh_return_i64,   eh_sjlj_callsite,   eh_sjlj_functioncontext,   eh_sjlj_longjmp,   eh_sjlj_lsda,   eh_sjlj_setjmp,   eh_typeid_for,   eh_unwind_init,   exp,   exp2,   expect,   fabs,   floor,   flt_rounds,   fma,   fmuladd,   frameaddress,   gcread,   gcroot,   gcwrite,   hexagon_A2_abs,   hexagon_A2_absp,   hexagon_A2_abssat,   hexagon_A2_add,   hexagon_A2_addh_h16_hh,   hexagon_A2_addh_h16_hl,   hexagon_A2_addh_h16_lh,   hexagon_A2_addh_h16_ll,   hexagon_A2_addh_h16_sat_hh,   hexagon_A2_addh_h16_sat_hl,   hexagon_A2_addh_h16_sat_lh,   hexagon_A2_addh_h16_sat_ll,   hexagon_A2_addh_l16_hl,   hexagon_A2_addh_l16_ll,   hexagon_A2_addh_l16_sat_hl,   hexagon_A2_addh_l16_sat_ll,   hexagon_A2_addi,   hexagon_A2_addp,   hexagon_A2_addpsat,   hexagon_A2_addsat,   hexagon_A2_addsp,   hexagon_A2_and,   hexagon_A2_andir,   hexagon_A2_andp,   hexagon_A2_aslh,   hexagon_A2_asrh,   hexagon_A2_combine_hh,   hexagon_A2_combine_hl,   hexagon_A2_combine_lh,   hexagon_A2_combine_ll,   hexagon_A2_combineii,   hexagon_A2_combinew,   hexagon_A2_max,   hexagon_A2_maxp,   hexagon_A2_maxu,   hexagon_A2_maxup,   hexagon_A2_min,   hexagon_A2_minp,   hexagon_A2_minu,   hexagon_A2_minup,   hexagon_A2_neg,   hexagon_A2_negp,   hexagon_A2_negsat,   hexagon_A2_not,   hexagon_A2_notp,   hexagon_A2_or,   hexagon_A2_orir,   hexagon_A2_orp,   hexagon_A2_roundsat,   hexagon_A2_sat,   hexagon_A2_satb,   hexagon_A2_sath,   hexagon_A2_satub,   hexagon_A2_satuh,   hexagon_A2_sub,   hexagon_A2_subh_h16_hh,   hexagon_A2_subh_h16_hl,   hexagon_A2_subh_h16_lh,   hexagon_A2_subh_h16_ll,   hexagon_A2_subh_h16_sat_hh,   hexagon_A2_subh_h16_sat_hl,   hexagon_A2_subh_h16_sat_lh,   hexagon_A2_subh_h16_sat_ll,   hexagon_A2_subh_l16_hl,   hexagon_A2_subh_l16_ll,   hexagon_A2_subh_l16_sat_hl,   hexagon_A2_subh_l16_sat_ll,   hexagon_A2_subp,   hexagon_A2_subri,   hexagon_A2_subsat,   hexagon_A2_svaddh,   hexagon_A2_svaddhs,   hexagon_A2_svadduhs,   hexagon_A2_svavgh,   hexagon_A2_svavghs,   hexagon_A2_svnavgh,   hexagon_A2_svsubh,   hexagon_A2_svsubhs,   hexagon_A2_svsubuhs,   hexagon_A2_swiz,   hexagon_A2_sxtb,   hexagon_A2_sxth,   hexagon_A2_sxtw,   hexagon_A2_tfr,   hexagon_A2_tfrih,   hexagon_A2_tfril,   hexagon_A2_tfrp,   hexagon_A2_tfrpi,   hexagon_A2_tfrsi,   hexagon_A2_vabsh,   hexagon_A2_vabshsat,   hexagon_A2_vabsw,   hexagon_A2_vabswsat,   hexagon_A2_vaddb_map,   hexagon_A2_vaddh,   hexagon_A2_vaddhs,   hexagon_A2_vaddub,   hexagon_A2_vaddubs,   hexagon_A2_vadduhs,   hexagon_A2_vaddw,   hexagon_A2_vaddws,   hexagon_A2_vavgh,   hexagon_A2_vavghcr,   hexagon_A2_vavghr,   hexagon_A2_vavgub,   hexagon_A2_vavgubr,   hexagon_A2_vavguh,   hexagon_A2_vavguhr,   hexagon_A2_vavguw,   hexagon_A2_vavguwr,   hexagon_A2_vavgw,   hexagon_A2_vavgwcr,   hexagon_A2_vavgwr,   hexagon_A2_vcmpbeq,   hexagon_A2_vcmpbgtu,   hexagon_A2_vcmpheq,   hexagon_A2_vcmphgt,   hexagon_A2_vcmphgtu,   hexagon_A2_vcmpweq,   hexagon_A2_vcmpwgt,   hexagon_A2_vcmpwgtu,   hexagon_A2_vconj,   hexagon_A2_vmaxb,   hexagon_A2_vmaxh,   hexagon_A2_vmaxub,   hexagon_A2_vmaxuh,   hexagon_A2_vmaxuw,   hexagon_A2_vmaxw,   hexagon_A2_vminb,   hexagon_A2_vminh,   hexagon_A2_vminub,   hexagon_A2_vminuh,   hexagon_A2_vminuw,   hexagon_A2_vminw,   hexagon_A2_vnavgh,   hexagon_A2_vnavghcr,   hexagon_A2_vnavghr,   hexagon_A2_vnavgw,   hexagon_A2_vnavgwcr,   hexagon_A2_vnavgwr,   hexagon_A2_vraddub,   hexagon_A2_vraddub_acc,   hexagon_A2_vrsadub,   hexagon_A2_vrsadub_acc,   hexagon_A2_vsubb_map,   hexagon_A2_vsubh,   hexagon_A2_vsubhs,   hexagon_A2_vsubub,   hexagon_A2_vsububs,   hexagon_A2_vsubuhs,   hexagon_A2_vsubw,   hexagon_A2_vsubws,   hexagon_A2_xor,   hexagon_A2_xorp,   hexagon_A2_zxtb,   hexagon_A2_zxth,   hexagon_A4_andn,   hexagon_A4_andnp,   hexagon_A4_bitsplit,   hexagon_A4_bitspliti,   hexagon_A4_boundscheck,   hexagon_A4_cmpbeq,   hexagon_A4_cmpbeqi,   hexagon_A4_cmpbgt,   hexagon_A4_cmpbgti,   hexagon_A4_cmpbgtu,   hexagon_A4_cmpbgtui,   hexagon_A4_cmpheq,   hexagon_A4_cmpheqi,   hexagon_A4_cmphgt,   hexagon_A4_cmphgti,   hexagon_A4_cmphgtu,   hexagon_A4_cmphgtui,   hexagon_A4_combineir,   hexagon_A4_combineri,   hexagon_A4_cround_ri,   hexagon_A4_cround_rr,   hexagon_A4_modwrapu,   hexagon_A4_orn,   hexagon_A4_ornp,   hexagon_A4_rcmpeq,   hexagon_A4_rcmpeqi,   hexagon_A4_rcmpneq,   hexagon_A4_rcmpneqi,   hexagon_A4_round_ri,   hexagon_A4_round_ri_sat,   hexagon_A4_round_rr,   hexagon_A4_round_rr_sat,   hexagon_A4_tlbmatch,   hexagon_A4_vcmpbeq_any,   hexagon_A4_vcmpbeqi,   hexagon_A4_vcmpbgt,   hexagon_A4_vcmpbgti,   hexagon_A4_vcmpbgtui,   hexagon_A4_vcmpheqi,   hexagon_A4_vcmphgti,   hexagon_A4_vcmphgtui,   hexagon_A4_vcmpweqi,   hexagon_A4_vcmpwgti,   hexagon_A4_vcmpwgtui,   hexagon_A4_vrmaxh,   hexagon_A4_vrmaxuh,   hexagon_A4_vrmaxuw,   hexagon_A4_vrmaxw,   hexagon_A4_vrminh,   hexagon_A4_vrminuh,   hexagon_A4_vrminuw,   hexagon_A4_vrminw,   hexagon_A5_vaddhubs,   hexagon_C2_all8,   hexagon_C2_and,   hexagon_C2_andn,   hexagon_C2_any8,   hexagon_C2_bitsclr,   hexagon_C2_bitsclri,   hexagon_C2_bitsset,   hexagon_C2_cmpeq,   hexagon_C2_cmpeqi,   hexagon_C2_cmpeqp,   hexagon_C2_cmpgei,   hexagon_C2_cmpgeui,   hexagon_C2_cmpgt,   hexagon_C2_cmpgti,   hexagon_C2_cmpgtp,   hexagon_C2_cmpgtu,   hexagon_C2_cmpgtui,   hexagon_C2_cmpgtup,   hexagon_C2_cmplt,   hexagon_C2_cmpltu,   hexagon_C2_mask,   hexagon_C2_mux,   hexagon_C2_muxii,   hexagon_C2_muxir,   hexagon_C2_muxri,   hexagon_C2_not,   hexagon_C2_or,   hexagon_C2_orn,   hexagon_C2_pxfer_map,   hexagon_C2_tfrpr,   hexagon_C2_tfrrp,   hexagon_C2_vitpack,   hexagon_C2_vmux,   hexagon_C2_xor,   hexagon_C4_and_and,   hexagon_C4_and_andn,   hexagon_C4_and_or,   hexagon_C4_and_orn,   hexagon_C4_cmplte,   hexagon_C4_cmpltei,   hexagon_C4_cmplteu,   hexagon_C4_cmplteui,   hexagon_C4_cmpneq,   hexagon_C4_cmpneqi,   hexagon_C4_fastcorner9,   hexagon_C4_fastcorner9_not,   hexagon_C4_nbitsclr,   hexagon_C4_nbitsclri,   hexagon_C4_nbitsset,   hexagon_C4_or_and,   hexagon_C4_or_andn,   hexagon_C4_or_or,   hexagon_C4_or_orn,   hexagon_F2_conv_d2df,   hexagon_F2_conv_d2sf,   hexagon_F2_conv_df2d,   hexagon_F2_conv_df2d_chop,   hexagon_F2_conv_df2sf,   hexagon_F2_conv_df2ud,   hexagon_F2_conv_df2ud_chop,   hexagon_F2_conv_df2uw,   hexagon_F2_conv_df2uw_chop,   hexagon_F2_conv_df2w,   hexagon_F2_conv_df2w_chop,   hexagon_F2_conv_sf2d,   hexagon_F2_conv_sf2d_chop,   hexagon_F2_conv_sf2df,   hexagon_F2_conv_sf2ud,   hexagon_F2_conv_sf2ud_chop,   hexagon_F2_conv_sf2uw,   hexagon_F2_conv_sf2uw_chop,   hexagon_F2_conv_sf2w,   hexagon_F2_conv_sf2w_chop,   hexagon_F2_conv_ud2df,   hexagon_F2_conv_ud2sf,   hexagon_F2_conv_uw2df,   hexagon_F2_conv_uw2sf,   hexagon_F2_conv_w2df,   hexagon_F2_conv_w2sf,   hexagon_F2_dfadd,   hexagon_F2_dfclass,   hexagon_F2_dfcmpeq,   hexagon_F2_dfcmpge,   hexagon_F2_dfcmpgt,   hexagon_F2_dfcmpuo,   hexagon_F2_dffixupd,   hexagon_F2_dffixupn,   hexagon_F2_dffixupr,   hexagon_F2_dffma,   hexagon_F2_dffma_lib,   hexagon_F2_dffma_sc,   hexagon_F2_dffms,   hexagon_F2_dffms_lib,   hexagon_F2_dfimm_n,   hexagon_F2_dfimm_p,   hexagon_F2_dfmax,   hexagon_F2_dfmin,   hexagon_F2_dfmpy,   hexagon_F2_dfsub,   hexagon_F2_sfadd,   hexagon_F2_sfclass,   hexagon_F2_sfcmpeq,   hexagon_F2_sfcmpge,   hexagon_F2_sfcmpgt,   hexagon_F2_sfcmpuo,   hexagon_F2_sffixupd,   hexagon_F2_sffixupn,   hexagon_F2_sffixupr,   hexagon_F2_sffma,   hexagon_F2_sffma_lib,   hexagon_F2_sffma_sc,   hexagon_F2_sffms,   hexagon_F2_sffms_lib,   hexagon_F2_sfimm_n,   hexagon_F2_sfimm_p,   hexagon_F2_sfmax,   hexagon_F2_sfmin,   hexagon_F2_sfmpy,   hexagon_F2_sfsub,   hexagon_M2_acci,   hexagon_M2_accii,   hexagon_M2_cmaci_s0,   hexagon_M2_cmacr_s0,   hexagon_M2_cmacs_s0,   hexagon_M2_cmacs_s1,   hexagon_M2_cmacsc_s0,   hexagon_M2_cmacsc_s1,   hexagon_M2_cmpyi_s0,   hexagon_M2_cmpyr_s0,   hexagon_M2_cmpyrs_s0,   hexagon_M2_cmpyrs_s1,   hexagon_M2_cmpyrsc_s0,   hexagon_M2_cmpyrsc_s1,   hexagon_M2_cmpys_s0,   hexagon_M2_cmpys_s1,   hexagon_M2_cmpysc_s0,   hexagon_M2_cmpysc_s1,   hexagon_M2_cnacs_s0,   hexagon_M2_cnacs_s1,   hexagon_M2_cnacsc_s0,   hexagon_M2_cnacsc_s1,   hexagon_M2_dpmpyss_acc_s0,   hexagon_M2_dpmpyss_nac_s0,   hexagon_M2_dpmpyss_rnd_s0,   hexagon_M2_dpmpyss_s0,   hexagon_M2_dpmpyuu_acc_s0,   hexagon_M2_dpmpyuu_nac_s0,   hexagon_M2_dpmpyuu_s0,   hexagon_M2_hmmpyh_rs1,   hexagon_M2_hmmpyh_s1,   hexagon_M2_hmmpyl_rs1,   hexagon_M2_hmmpyl_s1,   hexagon_M2_maci,   hexagon_M2_macsin,   hexagon_M2_macsip,   hexagon_M2_mmachs_rs0,   hexagon_M2_mmachs_rs1,   hexagon_M2_mmachs_s0,   hexagon_M2_mmachs_s1,   hexagon_M2_mmacls_rs0,   hexagon_M2_mmacls_rs1,   hexagon_M2_mmacls_s0,   hexagon_M2_mmacls_s1,   hexagon_M2_mmacuhs_rs0,   hexagon_M2_mmacuhs_rs1,   hexagon_M2_mmacuhs_s0,   hexagon_M2_mmacuhs_s1,   hexagon_M2_mmaculs_rs0,   hexagon_M2_mmaculs_rs1,   hexagon_M2_mmaculs_s0,   hexagon_M2_mmaculs_s1,   hexagon_M2_mmpyh_rs0,   hexagon_M2_mmpyh_rs1,   hexagon_M2_mmpyh_s0,   hexagon_M2_mmpyh_s1,   hexagon_M2_mmpyl_rs0,   hexagon_M2_mmpyl_rs1,   hexagon_M2_mmpyl_s0,   hexagon_M2_mmpyl_s1,   hexagon_M2_mmpyuh_rs0,   hexagon_M2_mmpyuh_rs1,   hexagon_M2_mmpyuh_s0,   hexagon_M2_mmpyuh_s1,   hexagon_M2_mmpyul_rs0,   hexagon_M2_mmpyul_rs1,   hexagon_M2_mmpyul_s0,   hexagon_M2_mmpyul_s1,   hexagon_M2_mpy_acc_hh_s0,   hexagon_M2_mpy_acc_hh_s1,   hexagon_M2_mpy_acc_hl_s0,   hexagon_M2_mpy_acc_hl_s1,   hexagon_M2_mpy_acc_lh_s0,   hexagon_M2_mpy_acc_lh_s1,   hexagon_M2_mpy_acc_ll_s0,   hexagon_M2_mpy_acc_ll_s1,   hexagon_M2_mpy_acc_sat_hh_s0,   hexagon_M2_mpy_acc_sat_hh_s1,   hexagon_M2_mpy_acc_sat_hl_s0,   hexagon_M2_mpy_acc_sat_hl_s1,   hexagon_M2_mpy_acc_sat_lh_s0,   hexagon_M2_mpy_acc_sat_lh_s1,   hexagon_M2_mpy_acc_sat_ll_s0,   hexagon_M2_mpy_acc_sat_ll_s1,   hexagon_M2_mpy_hh_s0,   hexagon_M2_mpy_hh_s1,   hexagon_M2_mpy_hl_s0,   hexagon_M2_mpy_hl_s1,   hexagon_M2_mpy_lh_s0,   hexagon_M2_mpy_lh_s1,   hexagon_M2_mpy_ll_s0,   hexagon_M2_mpy_ll_s1,   hexagon_M2_mpy_nac_hh_s0,   hexagon_M2_mpy_nac_hh_s1,   hexagon_M2_mpy_nac_hl_s0,   hexagon_M2_mpy_nac_hl_s1,   hexagon_M2_mpy_nac_lh_s0,   hexagon_M2_mpy_nac_lh_s1,   hexagon_M2_mpy_nac_ll_s0,   hexagon_M2_mpy_nac_ll_s1,   hexagon_M2_mpy_nac_sat_hh_s0,   hexagon_M2_mpy_nac_sat_hh_s1,   hexagon_M2_mpy_nac_sat_hl_s0,   hexagon_M2_mpy_nac_sat_hl_s1,   hexagon_M2_mpy_nac_sat_lh_s0,   hexagon_M2_mpy_nac_sat_lh_s1,   hexagon_M2_mpy_nac_sat_ll_s0,   hexagon_M2_mpy_nac_sat_ll_s1,   hexagon_M2_mpy_rnd_hh_s0,   hexagon_M2_mpy_rnd_hh_s1,   hexagon_M2_mpy_rnd_hl_s0,   hexagon_M2_mpy_rnd_hl_s1,   hexagon_M2_mpy_rnd_lh_s0,   hexagon_M2_mpy_rnd_lh_s1,   hexagon_M2_mpy_rnd_ll_s0,   hexagon_M2_mpy_rnd_ll_s1,   hexagon_M2_mpy_sat_hh_s0,   hexagon_M2_mpy_sat_hh_s1,   hexagon_M2_mpy_sat_hl_s0,   hexagon_M2_mpy_sat_hl_s1,   hexagon_M2_mpy_sat_lh_s0,   hexagon_M2_mpy_sat_lh_s1,   hexagon_M2_mpy_sat_ll_s0,   hexagon_M2_mpy_sat_ll_s1,   hexagon_M2_mpy_sat_rnd_hh_s0,   hexagon_M2_mpy_sat_rnd_hh_s1,   hexagon_M2_mpy_sat_rnd_hl_s0,   hexagon_M2_mpy_sat_rnd_hl_s1,   hexagon_M2_mpy_sat_rnd_lh_s0,   hexagon_M2_mpy_sat_rnd_lh_s1,   hexagon_M2_mpy_sat_rnd_ll_s0,   hexagon_M2_mpy_sat_rnd_ll_s1,   hexagon_M2_mpy_up,   hexagon_M2_mpy_up_s1,   hexagon_M2_mpy_up_s1_sat,   hexagon_M2_mpyd_acc_hh_s0,   hexagon_M2_mpyd_acc_hh_s1,   hexagon_M2_mpyd_acc_hl_s0,   hexagon_M2_mpyd_acc_hl_s1,   hexagon_M2_mpyd_acc_lh_s0,   hexagon_M2_mpyd_acc_lh_s1,   hexagon_M2_mpyd_acc_ll_s0,   hexagon_M2_mpyd_acc_ll_s1,   hexagon_M2_mpyd_hh_s0,   hexagon_M2_mpyd_hh_s1,   hexagon_M2_mpyd_hl_s0,   hexagon_M2_mpyd_hl_s1,   hexagon_M2_mpyd_lh_s0,   hexagon_M2_mpyd_lh_s1,   hexagon_M2_mpyd_ll_s0,   hexagon_M2_mpyd_ll_s1,   hexagon_M2_mpyd_nac_hh_s0,   hexagon_M2_mpyd_nac_hh_s1,   hexagon_M2_mpyd_nac_hl_s0,   hexagon_M2_mpyd_nac_hl_s1,   hexagon_M2_mpyd_nac_lh_s0,   hexagon_M2_mpyd_nac_lh_s1,   hexagon_M2_mpyd_nac_ll_s0,   hexagon_M2_mpyd_nac_ll_s1,   hexagon_M2_mpyd_rnd_hh_s0,   hexagon_M2_mpyd_rnd_hh_s1,   hexagon_M2_mpyd_rnd_hl_s0,   hexagon_M2_mpyd_rnd_hl_s1,   hexagon_M2_mpyd_rnd_lh_s0,   hexagon_M2_mpyd_rnd_lh_s1,   hexagon_M2_mpyd_rnd_ll_s0,   hexagon_M2_mpyd_rnd_ll_s1,   hexagon_M2_mpyi,   hexagon_M2_mpysmi,   hexagon_M2_mpysu_up,   hexagon_M2_mpyu_acc_hh_s0,   hexagon_M2_mpyu_acc_hh_s1,   hexagon_M2_mpyu_acc_hl_s0,   hexagon_M2_mpyu_acc_hl_s1,   hexagon_M2_mpyu_acc_lh_s0,   hexagon_M2_mpyu_acc_lh_s1,   hexagon_M2_mpyu_acc_ll_s0,   hexagon_M2_mpyu_acc_ll_s1,   hexagon_M2_mpyu_hh_s0,   hexagon_M2_mpyu_hh_s1,   hexagon_M2_mpyu_hl_s0,   hexagon_M2_mpyu_hl_s1,   hexagon_M2_mpyu_lh_s0,   hexagon_M2_mpyu_lh_s1,   hexagon_M2_mpyu_ll_s0,   hexagon_M2_mpyu_ll_s1,   hexagon_M2_mpyu_nac_hh_s0,   hexagon_M2_mpyu_nac_hh_s1,   hexagon_M2_mpyu_nac_hl_s0,   hexagon_M2_mpyu_nac_hl_s1,   hexagon_M2_mpyu_nac_lh_s0,   hexagon_M2_mpyu_nac_lh_s1,   hexagon_M2_mpyu_nac_ll_s0,   hexagon_M2_mpyu_nac_ll_s1,   hexagon_M2_mpyu_up,   hexagon_M2_mpyud_acc_hh_s0,   hexagon_M2_mpyud_acc_hh_s1,   hexagon_M2_mpyud_acc_hl_s0,   hexagon_M2_mpyud_acc_hl_s1,   hexagon_M2_mpyud_acc_lh_s0,   hexagon_M2_mpyud_acc_lh_s1,   hexagon_M2_mpyud_acc_ll_s0,   hexagon_M2_mpyud_acc_ll_s1,   hexagon_M2_mpyud_hh_s0,   hexagon_M2_mpyud_hh_s1,   hexagon_M2_mpyud_hl_s0,   hexagon_M2_mpyud_hl_s1,   hexagon_M2_mpyud_lh_s0,   hexagon_M2_mpyud_lh_s1,   hexagon_M2_mpyud_ll_s0,   hexagon_M2_mpyud_ll_s1,   hexagon_M2_mpyud_nac_hh_s0,   hexagon_M2_mpyud_nac_hh_s1,   hexagon_M2_mpyud_nac_hl_s0,   hexagon_M2_mpyud_nac_hl_s1,   hexagon_M2_mpyud_nac_lh_s0,   hexagon_M2_mpyud_nac_lh_s1,   hexagon_M2_mpyud_nac_ll_s0,   hexagon_M2_mpyud_nac_ll_s1,   hexagon_M2_mpyui,   hexagon_M2_nacci,   hexagon_M2_naccii,   hexagon_M2_subacc,   hexagon_M2_vabsdiffh,   hexagon_M2_vabsdiffw,   hexagon_M2_vcmac_s0_sat_i,   hexagon_M2_vcmac_s0_sat_r,   hexagon_M2_vcmpy_s0_sat_i,   hexagon_M2_vcmpy_s0_sat_r,   hexagon_M2_vcmpy_s1_sat_i,   hexagon_M2_vcmpy_s1_sat_r,   hexagon_M2_vdmacs_s0,   hexagon_M2_vdmacs_s1,   hexagon_M2_vdmpyrs_s0,   hexagon_M2_vdmpyrs_s1,   hexagon_M2_vdmpys_s0,   hexagon_M2_vdmpys_s1,   hexagon_M2_vmac2,   hexagon_M2_vmac2es,   hexagon_M2_vmac2es_s0,   hexagon_M2_vmac2es_s1,   hexagon_M2_vmac2s_s0,   hexagon_M2_vmac2s_s1,   hexagon_M2_vmac2su_s0,   hexagon_M2_vmac2su_s1,   hexagon_M2_vmpy2es_s0,   hexagon_M2_vmpy2es_s1,   hexagon_M2_vmpy2s_s0,   hexagon_M2_vmpy2s_s0pack,   hexagon_M2_vmpy2s_s1,   hexagon_M2_vmpy2s_s1pack,   hexagon_M2_vmpy2su_s0,   hexagon_M2_vmpy2su_s1,   hexagon_M2_vraddh,   hexagon_M2_vradduh,   hexagon_M2_vrcmaci_s0,   hexagon_M2_vrcmaci_s0c,   hexagon_M2_vrcmacr_s0,   hexagon_M2_vrcmacr_s0c,   hexagon_M2_vrcmpyi_s0,   hexagon_M2_vrcmpyi_s0c,   hexagon_M2_vrcmpyr_s0,   hexagon_M2_vrcmpyr_s0c,   hexagon_M2_vrcmpys_acc_s1,   hexagon_M2_vrcmpys_s1,   hexagon_M2_vrcmpys_s1rp,   hexagon_M2_vrmac_s0,   hexagon_M2_vrmpy_s0,   hexagon_M2_xor_xacc,   hexagon_M4_and_and,   hexagon_M4_and_andn,   hexagon_M4_and_or,   hexagon_M4_and_xor,   hexagon_M4_cmpyi_wh,   hexagon_M4_cmpyi_whc,   hexagon_M4_cmpyr_wh,   hexagon_M4_cmpyr_whc,   hexagon_M4_mac_up_s1_sat,   hexagon_M4_mpyri_addi,   hexagon_M4_mpyri_addr,   hexagon_M4_mpyri_addr_u2,   hexagon_M4_mpyrr_addi,   hexagon_M4_mpyrr_addr,   hexagon_M4_nac_up_s1_sat,   hexagon_M4_or_and,   hexagon_M4_or_andn,   hexagon_M4_or_or,   hexagon_M4_or_xor,   hexagon_M4_pmpyw,   hexagon_M4_pmpyw_acc,   hexagon_M4_vpmpyh,   hexagon_M4_vpmpyh_acc,   hexagon_M4_vrmpyeh_acc_s0,   hexagon_M4_vrmpyeh_acc_s1,   hexagon_M4_vrmpyeh_s0,   hexagon_M4_vrmpyeh_s1,   hexagon_M4_vrmpyoh_acc_s0,   hexagon_M4_vrmpyoh_acc_s1,   hexagon_M4_vrmpyoh_s0,   hexagon_M4_vrmpyoh_s1,   hexagon_M4_xor_and,   hexagon_M4_xor_andn,   hexagon_M4_xor_or,   hexagon_M4_xor_xacc,   hexagon_M5_vdmacbsu,   hexagon_M5_vdmpybsu,   hexagon_M5_vmacbsu,   hexagon_M5_vmacbuu,   hexagon_M5_vmpybsu,   hexagon_M5_vmpybuu,   hexagon_M5_vrmacbsu,   hexagon_M5_vrmacbuu,   hexagon_M5_vrmpybsu,   hexagon_M5_vrmpybuu,   hexagon_S2_addasl_rrri,   hexagon_S2_asl_i_p,   hexagon_S2_asl_i_p_acc,   hexagon_S2_asl_i_p_and,   hexagon_S2_asl_i_p_nac,   hexagon_S2_asl_i_p_or,   hexagon_S2_asl_i_p_xacc,   hexagon_S2_asl_i_r,   hexagon_S2_asl_i_r_acc,   hexagon_S2_asl_i_r_and,   hexagon_S2_asl_i_r_nac,   hexagon_S2_asl_i_r_or,   hexagon_S2_asl_i_r_sat,   hexagon_S2_asl_i_r_xacc,   hexagon_S2_asl_i_vh,   hexagon_S2_asl_i_vw,   hexagon_S2_asl_r_p,   hexagon_S2_asl_r_p_acc,   hexagon_S2_asl_r_p_and,   hexagon_S2_asl_r_p_nac,   hexagon_S2_asl_r_p_or,   hexagon_S2_asl_r_p_xor,   hexagon_S2_asl_r_r,   hexagon_S2_asl_r_r_acc,   hexagon_S2_asl_r_r_and,   hexagon_S2_asl_r_r_nac,   hexagon_S2_asl_r_r_or,   hexagon_S2_asl_r_r_sat,   hexagon_S2_asl_r_vh,   hexagon_S2_asl_r_vw,   hexagon_S2_asr_i_p,   hexagon_S2_asr_i_p_acc,   hexagon_S2_asr_i_p_and,   hexagon_S2_asr_i_p_nac,   hexagon_S2_asr_i_p_or,   hexagon_S2_asr_i_p_rnd,   hexagon_S2_asr_i_p_rnd_goodsyntax,   hexagon_S2_asr_i_r,   hexagon_S2_asr_i_r_acc,   hexagon_S2_asr_i_r_and,   hexagon_S2_asr_i_r_nac,   hexagon_S2_asr_i_r_or,   hexagon_S2_asr_i_r_rnd,   hexagon_S2_asr_i_r_rnd_goodsyntax,   hexagon_S2_asr_i_svw_trun,   hexagon_S2_asr_i_vh,   hexagon_S2_asr_i_vw,   hexagon_S2_asr_r_p,   hexagon_S2_asr_r_p_acc,   hexagon_S2_asr_r_p_and,   hexagon_S2_asr_r_p_nac,   hexagon_S2_asr_r_p_or,   hexagon_S2_asr_r_p_xor,   hexagon_S2_asr_r_r,   hexagon_S2_asr_r_r_acc,   hexagon_S2_asr_r_r_and,   hexagon_S2_asr_r_r_nac,   hexagon_S2_asr_r_r_or,   hexagon_S2_asr_r_r_sat,   hexagon_S2_asr_r_svw_trun,   hexagon_S2_asr_r_vh,   hexagon_S2_asr_r_vw,   hexagon_S2_brev,   hexagon_S2_brevp,   hexagon_S2_cl0,   hexagon_S2_cl0p,   hexagon_S2_cl1,   hexagon_S2_cl1p,   hexagon_S2_clb,   hexagon_S2_clbnorm,   hexagon_S2_clbp,   hexagon_S2_clrbit_i,   hexagon_S2_clrbit_r,   hexagon_S2_ct0,   hexagon_S2_ct0p,   hexagon_S2_ct1,   hexagon_S2_ct1p,   hexagon_S2_deinterleave,   hexagon_S2_extractu,   hexagon_S2_extractu_rp,   hexagon_S2_extractup,   hexagon_S2_extractup_rp,   hexagon_S2_insert,   hexagon_S2_insert_rp,   hexagon_S2_insertp,   hexagon_S2_insertp_rp,   hexagon_S2_interleave,   hexagon_S2_lfsp,   hexagon_S2_lsl_r_p,   hexagon_S2_lsl_r_p_acc,   hexagon_S2_lsl_r_p_and,   hexagon_S2_lsl_r_p_nac,   hexagon_S2_lsl_r_p_or,   hexagon_S2_lsl_r_p_xor,   hexagon_S2_lsl_r_r,   hexagon_S2_lsl_r_r_acc,   hexagon_S2_lsl_r_r_and,   hexagon_S2_lsl_r_r_nac,   hexagon_S2_lsl_r_r_or,   hexagon_S2_lsl_r_vh,   hexagon_S2_lsl_r_vw,   hexagon_S2_lsr_i_p,   hexagon_S2_lsr_i_p_acc,   hexagon_S2_lsr_i_p_and,   hexagon_S2_lsr_i_p_nac,   hexagon_S2_lsr_i_p_or,   hexagon_S2_lsr_i_p_xacc,   hexagon_S2_lsr_i_r,   hexagon_S2_lsr_i_r_acc,   hexagon_S2_lsr_i_r_and,   hexagon_S2_lsr_i_r_nac,   hexagon_S2_lsr_i_r_or,   hexagon_S2_lsr_i_r_xacc,   hexagon_S2_lsr_i_vh,   hexagon_S2_lsr_i_vw,   hexagon_S2_lsr_r_p,   hexagon_S2_lsr_r_p_acc,   hexagon_S2_lsr_r_p_and,   hexagon_S2_lsr_r_p_nac,   hexagon_S2_lsr_r_p_or,   hexagon_S2_lsr_r_p_xor,   hexagon_S2_lsr_r_r,   hexagon_S2_lsr_r_r_acc,   hexagon_S2_lsr_r_r_and,   hexagon_S2_lsr_r_r_nac,   hexagon_S2_lsr_r_r_or,   hexagon_S2_lsr_r_vh,   hexagon_S2_lsr_r_vw,   hexagon_S2_packhl,   hexagon_S2_parityp,   hexagon_S2_setbit_i,   hexagon_S2_setbit_r,   hexagon_S2_shuffeb,   hexagon_S2_shuffeh,   hexagon_S2_shuffob,   hexagon_S2_shuffoh,   hexagon_S2_svsathb,   hexagon_S2_svsathub,   hexagon_S2_tableidxb_goodsyntax,   hexagon_S2_tableidxd_goodsyntax,   hexagon_S2_tableidxh_goodsyntax,   hexagon_S2_tableidxw_goodsyntax,   hexagon_S2_togglebit_i,   hexagon_S2_togglebit_r,   hexagon_S2_tstbit_i,   hexagon_S2_tstbit_r,   hexagon_S2_valignib,   hexagon_S2_valignrb,   hexagon_S2_vcnegh,   hexagon_S2_vcrotate,   hexagon_S2_vrcnegh,   hexagon_S2_vrndpackwh,   hexagon_S2_vrndpackwhs,   hexagon_S2_vsathb,   hexagon_S2_vsathb_nopack,   hexagon_S2_vsathub,   hexagon_S2_vsathub_nopack,   hexagon_S2_vsatwh,   hexagon_S2_vsatwh_nopack,   hexagon_S2_vsatwuh,   hexagon_S2_vsatwuh_nopack,   hexagon_S2_vsplatrb,   hexagon_S2_vsplatrh,   hexagon_S2_vspliceib,   hexagon_S2_vsplicerb,   hexagon_S2_vsxtbh,   hexagon_S2_vsxthw,   hexagon_S2_vtrunehb,   hexagon_S2_vtrunewh,   hexagon_S2_vtrunohb,   hexagon_S2_vtrunowh,   hexagon_S2_vzxtbh,   hexagon_S2_vzxthw,   hexagon_S4_addaddi,   hexagon_S4_addi_asl_ri,   hexagon_S4_addi_lsr_ri,   hexagon_S4_andi_asl_ri,   hexagon_S4_andi_lsr_ri,   hexagon_S4_clbaddi,   hexagon_S4_clbpaddi,   hexagon_S4_clbpnorm,   hexagon_S4_extract,   hexagon_S4_extract_rp,   hexagon_S4_extractp,   hexagon_S4_extractp_rp,   hexagon_S4_lsli,   hexagon_S4_ntstbit_i,   hexagon_S4_ntstbit_r,   hexagon_S4_or_andi,   hexagon_S4_or_andix,   hexagon_S4_or_ori,   hexagon_S4_ori_asl_ri,   hexagon_S4_ori_lsr_ri,   hexagon_S4_parity,   hexagon_S4_subaddi,   hexagon_S4_subi_asl_ri,   hexagon_S4_subi_lsr_ri,   hexagon_S4_vrcrotate,   hexagon_S4_vrcrotate_acc,   hexagon_S4_vxaddsubh,   hexagon_S4_vxaddsubhr,   hexagon_S4_vxaddsubw,   hexagon_S4_vxsubaddh,   hexagon_S4_vxsubaddhr,   hexagon_S4_vxsubaddw,   hexagon_S5_asrhub_rnd_sat_goodsyntax,   hexagon_S5_asrhub_sat,   hexagon_S5_popcountp,   hexagon_S5_vasrhrnd_goodsyntax,   hexagon_SI_to_SXTHI_asrh,   hexagon_circ_ldd,   init_trampoline,   invariant_end,   invariant_start,   lifetime_end,   lifetime_start,   log,   log10,   log2,   longjmp,   memcpy,   memmove,   memset,   mips_absq_s_ph,   mips_absq_s_qb,   mips_absq_s_w,   mips_add_a_b,   mips_add_a_d,   mips_add_a_h,   mips_add_a_w,   mips_addq_ph,   mips_addq_s_ph,   mips_addq_s_w,   mips_addqh_ph,   mips_addqh_r_ph,   mips_addqh_r_w,   mips_addqh_w,   mips_adds_a_b,   mips_adds_a_d,   mips_adds_a_h,   mips_adds_a_w,   mips_adds_s_b,   mips_adds_s_d,   mips_adds_s_h,   mips_adds_s_w,   mips_adds_u_b,   mips_adds_u_d,   mips_adds_u_h,   mips_adds_u_w,   mips_addsc,   mips_addu_ph,   mips_addu_qb,   mips_addu_s_ph,   mips_addu_s_qb,   mips_adduh_qb,   mips_adduh_r_qb,   mips_addv_b,   mips_addv_d,   mips_addv_h,   mips_addv_w,   mips_addvi_b,   mips_addvi_d,   mips_addvi_h,   mips_addvi_w,   mips_addwc,   mips_and_v,   mips_andi_b,   mips_append,   mips_asub_s_b,   mips_asub_s_d,   mips_asub_s_h,   mips_asub_s_w,   mips_asub_u_b,   mips_asub_u_d,   mips_asub_u_h,   mips_asub_u_w,   mips_ave_s_b,   mips_ave_s_d,   mips_ave_s_h,   mips_ave_s_w,   mips_ave_u_b,   mips_ave_u_d,   mips_ave_u_h,   mips_ave_u_w,   mips_aver_s_b,   mips_aver_s_d,   mips_aver_s_h,   mips_aver_s_w,   mips_aver_u_b,   mips_aver_u_d,   mips_aver_u_h,   mips_aver_u_w,   mips_balign,   mips_bclr_b,   mips_bclr_d,   mips_bclr_h,   mips_bclr_w,   mips_bclri_b,   mips_bclri_d,   mips_bclri_h,   mips_bclri_w,   mips_binsl_b,   mips_binsl_d,   mips_binsl_h,   mips_binsl_w,   mips_binsli_b,   mips_binsli_d,   mips_binsli_h,   mips_binsli_w,   mips_binsr_b,   mips_binsr_d,   mips_binsr_h,   mips_binsr_w,   mips_binsri_b,   mips_binsri_d,   mips_binsri_h,   mips_binsri_w,   mips_bitrev,   mips_bmnz_v,   mips_bmnzi_b,   mips_bmz_v,   mips_bmzi_b,   mips_bneg_b,   mips_bneg_d,   mips_bneg_h,   mips_bneg_w,   mips_bnegi_b,   mips_bnegi_d,   mips_bnegi_h,   mips_bnegi_w,   mips_bnz_b,   mips_bnz_d,   mips_bnz_h,   mips_bnz_v,   mips_bnz_w,   mips_bposge32,   mips_bsel_v,   mips_bseli_b,   mips_bset_b,   mips_bset_d,   mips_bset_h,   mips_bset_w,   mips_bseti_b,   mips_bseti_d,   mips_bseti_h,   mips_bseti_w,   mips_bz_b,   mips_bz_d,   mips_bz_h,   mips_bz_v,   mips_bz_w,   mips_ceq_b,   mips_ceq_d,   mips_ceq_h,   mips_ceq_w,   mips_ceqi_b,   mips_ceqi_d,   mips_ceqi_h,   mips_ceqi_w,   mips_cfcmsa,   mips_cle_s_b,   mips_cle_s_d,   mips_cle_s_h,   mips_cle_s_w,   mips_cle_u_b,   mips_cle_u_d,   mips_cle_u_h,   mips_cle_u_w,   mips_clei_s_b,   mips_clei_s_d,   mips_clei_s_h,   mips_clei_s_w,   mips_clei_u_b,   mips_clei_u_d,   mips_clei_u_h,   mips_clei_u_w,   mips_clt_s_b,   mips_clt_s_d,   mips_clt_s_h,   mips_clt_s_w,   mips_clt_u_b,   mips_clt_u_d,   mips_clt_u_h,   mips_clt_u_w,   mips_clti_s_b,   mips_clti_s_d,   mips_clti_s_h,   mips_clti_s_w,   mips_clti_u_b,   mips_clti_u_d,   mips_clti_u_h,   mips_clti_u_w,   mips_cmp_eq_ph,   mips_cmp_le_ph,   mips_cmp_lt_ph,   mips_cmpgdu_eq_qb,   mips_cmpgdu_le_qb,   mips_cmpgdu_lt_qb,   mips_cmpgu_eq_qb,   mips_cmpgu_le_qb,   mips_cmpgu_lt_qb,   mips_cmpu_eq_qb,   mips_cmpu_le_qb,   mips_cmpu_lt_qb,   mips_copy_s_b,   mips_copy_s_d,   mips_copy_s_h,   mips_copy_s_w,   mips_copy_u_b,   mips_copy_u_d,   mips_copy_u_h,   mips_copy_u_w,   mips_ctcmsa,   mips_div_s_b,   mips_div_s_d,   mips_div_s_h,   mips_div_s_w,   mips_div_u_b,   mips_div_u_d,   mips_div_u_h,   mips_div_u_w,   mips_dotp_s_d,   mips_dotp_s_h,   mips_dotp_s_w,   mips_dotp_u_d,   mips_dotp_u_h,   mips_dotp_u_w,   mips_dpa_w_ph,   mips_dpadd_s_d,   mips_dpadd_s_h,   mips_dpadd_s_w,   mips_dpadd_u_d,   mips_dpadd_u_h,   mips_dpadd_u_w,   mips_dpaq_s_w_ph,   mips_dpaq_sa_l_w,   mips_dpaqx_s_w_ph,   mips_dpaqx_sa_w_ph,   mips_dpau_h_qbl,   mips_dpau_h_qbr,   mips_dpax_w_ph,   mips_dps_w_ph,   mips_dpsq_s_w_ph,   mips_dpsq_sa_l_w,   mips_dpsqx_s_w_ph,   mips_dpsqx_sa_w_ph,   mips_dpsu_h_qbl,   mips_dpsu_h_qbr,   mips_dpsub_s_d,   mips_dpsub_s_h,   mips_dpsub_s_w,   mips_dpsub_u_d,   mips_dpsub_u_h,   mips_dpsub_u_w,   mips_dpsx_w_ph,   mips_extp,   mips_extpdp,   mips_extr_r_w,   mips_extr_rs_w,   mips_extr_s_h,   mips_extr_w,   mips_fadd_d,   mips_fadd_w,   mips_fcaf_d,   mips_fcaf_w,   mips_fceq_d,   mips_fceq_w,   mips_fclass_d,   mips_fclass_w,   mips_fcle_d,   mips_fcle_w,   mips_fclt_d,   mips_fclt_w,   mips_fcne_d,   mips_fcne_w,   mips_fcor_d,   mips_fcor_w,   mips_fcueq_d,   mips_fcueq_w,   mips_fcule_d,   mips_fcule_w,   mips_fcult_d,   mips_fcult_w,   mips_fcun_d,   mips_fcun_w,   mips_fcune_d,   mips_fcune_w,   mips_fdiv_d,   mips_fdiv_w,   mips_fexdo_h,   mips_fexdo_w,   mips_fexp2_d,   mips_fexp2_w,   mips_fexupl_d,   mips_fexupl_w,   mips_fexupr_d,   mips_fexupr_w,   mips_ffint_s_d,   mips_ffint_s_w,   mips_ffint_u_d,   mips_ffint_u_w,   mips_ffql_d,   mips_ffql_w,   mips_ffqr_d,   mips_ffqr_w,   mips_fill_b,   mips_fill_d,   mips_fill_h,   mips_fill_w,   mips_flog2_d,   mips_flog2_w,   mips_fmadd_d,   mips_fmadd_w,   mips_fmax_a_d,   mips_fmax_a_w,   mips_fmax_d,   mips_fmax_w,   mips_fmin_a_d,   mips_fmin_a_w,   mips_fmin_d,   mips_fmin_w,   mips_fmsub_d,   mips_fmsub_w,   mips_fmul_d,   mips_fmul_w,   mips_frcp_d,   mips_frcp_w,   mips_frint_d,   mips_frint_w,   mips_frsqrt_d,   mips_frsqrt_w,   mips_fsaf_d,   mips_fsaf_w,   mips_fseq_d,   mips_fseq_w,   mips_fsle_d,   mips_fsle_w,   mips_fslt_d,   mips_fslt_w,   mips_fsne_d,   mips_fsne_w,   mips_fsor_d,   mips_fsor_w,   mips_fsqrt_d,   mips_fsqrt_w,   mips_fsub_d,   mips_fsub_w,   mips_fsueq_d,   mips_fsueq_w,   mips_fsule_d,   mips_fsule_w,   mips_fsult_d,   mips_fsult_w,   mips_fsun_d,   mips_fsun_w,   mips_fsune_d,   mips_fsune_w,   mips_ftint_s_d,   mips_ftint_s_w,   mips_ftint_u_d,   mips_ftint_u_w,   mips_ftq_h,   mips_ftq_w,   mips_ftrunc_s_d,   mips_ftrunc_s_w,   mips_ftrunc_u_d,   mips_ftrunc_u_w,   mips_hadd_s_d,   mips_hadd_s_h,   mips_hadd_s_w,   mips_hadd_u_d,   mips_hadd_u_h,   mips_hadd_u_w,   mips_hsub_s_d,   mips_hsub_s_h,   mips_hsub_s_w,   mips_hsub_u_d,   mips_hsub_u_h,   mips_hsub_u_w,   mips_ilvev_b,   mips_ilvev_d,   mips_ilvev_h,   mips_ilvev_w,   mips_ilvl_b,   mips_ilvl_d,   mips_ilvl_h,   mips_ilvl_w,   mips_ilvod_b,   mips_ilvod_d,   mips_ilvod_h,   mips_ilvod_w,   mips_ilvr_b,   mips_ilvr_d,   mips_ilvr_h,   mips_ilvr_w,   mips_insert_b,   mips_insert_d,   mips_insert_h,   mips_insert_w,   mips_insv,   mips_insve_b,   mips_insve_d,   mips_insve_h,   mips_insve_w,   mips_lbux,   mips_ld_b,   mips_ld_d,   mips_ld_h,   mips_ld_w,   mips_ldi_b,   mips_ldi_d,   mips_ldi_h,   mips_ldi_w,   mips_ldx_b,   mips_ldx_d,   mips_ldx_h,   mips_ldx_w,   mips_lhx,   mips_lwx,   mips_madd,   mips_madd_q_h,   mips_madd_q_w,   mips_maddr_q_h,   mips_maddr_q_w,   mips_maddu,   mips_maddv_b,   mips_maddv_d,   mips_maddv_h,   mips_maddv_w,   mips_maq_s_w_phl,   mips_maq_s_w_phr,   mips_maq_sa_w_phl,   mips_maq_sa_w_phr,   mips_max_a_b,   mips_max_a_d,   mips_max_a_h,   mips_max_a_w,   mips_max_s_b,   mips_max_s_d,   mips_max_s_h,   mips_max_s_w,   mips_max_u_b,   mips_max_u_d,   mips_max_u_h,   mips_max_u_w,   mips_maxi_s_b,   mips_maxi_s_d,   mips_maxi_s_h,   mips_maxi_s_w,   mips_maxi_u_b,   mips_maxi_u_d,   mips_maxi_u_h,   mips_maxi_u_w,   mips_min_a_b,   mips_min_a_d,   mips_min_a_h,   mips_min_a_w,   mips_min_s_b,   mips_min_s_d,   mips_min_s_h,   mips_min_s_w,   mips_min_u_b,   mips_min_u_d,   mips_min_u_h,   mips_min_u_w,   mips_mini_s_b,   mips_mini_s_d,   mips_mini_s_h,   mips_mini_s_w,   mips_mini_u_b,   mips_mini_u_d,   mips_mini_u_h,   mips_mini_u_w,   mips_mod_s_b,   mips_mod_s_d,   mips_mod_s_h,   mips_mod_s_w,   mips_mod_u_b,   mips_mod_u_d,   mips_mod_u_h,   mips_mod_u_w,   mips_modsub,   mips_move_v,   mips_msub,   mips_msub_q_h,   mips_msub_q_w,   mips_msubr_q_h,   mips_msubr_q_w,   mips_msubu,   mips_msubv_b,   mips_msubv_d,   mips_msubv_h,   mips_msubv_w,   mips_mthlip,   mips_mul_ph,   mips_mul_q_h,   mips_mul_q_w,   mips_mul_s_ph,   mips_muleq_s_w_phl,   mips_muleq_s_w_phr,   mips_muleu_s_ph_qbl,   mips_muleu_s_ph_qbr,   mips_mulq_rs_ph,   mips_mulq_rs_w,   mips_mulq_s_ph,   mips_mulq_s_w,   mips_mulr_q_h,   mips_mulr_q_w,   mips_mulsa_w_ph,   mips_mulsaq_s_w_ph,   mips_mult,   mips_multu,   mips_mulv_b,   mips_mulv_d,   mips_mulv_h,   mips_mulv_w,   mips_nloc_b,   mips_nloc_d,   mips_nloc_h,   mips_nloc_w,   mips_nlzc_b,   mips_nlzc_d,   mips_nlzc_h,   mips_nlzc_w,   mips_nor_v,   mips_nori_b,   mips_or_v,   mips_ori_b,   mips_packrl_ph,   mips_pckev_b,   mips_pckev_d,   mips_pckev_h,   mips_pckev_w,   mips_pckod_b,   mips_pckod_d,   mips_pckod_h,   mips_pckod_w,   mips_pcnt_b,   mips_pcnt_d,   mips_pcnt_h,   mips_pcnt_w,   mips_pick_ph,   mips_pick_qb,   mips_preceq_w_phl,   mips_preceq_w_phr,   mips_precequ_ph_qbl,   mips_precequ_ph_qbla,   mips_precequ_ph_qbr,   mips_precequ_ph_qbra,   mips_preceu_ph_qbl,   mips_preceu_ph_qbla,   mips_preceu_ph_qbr,   mips_preceu_ph_qbra,   mips_precr_qb_ph,   mips_precr_sra_ph_w,   mips_precr_sra_r_ph_w,   mips_precrq_ph_w,   mips_precrq_qb_ph,   mips_precrq_rs_ph_w,   mips_precrqu_s_qb_ph,   mips_prepend,   mips_raddu_w_qb,   mips_rddsp,   mips_repl_ph,   mips_repl_qb,   mips_sat_s_b,   mips_sat_s_d,   mips_sat_s_h,   mips_sat_s_w,   mips_sat_u_b,   mips_sat_u_d,   mips_sat_u_h,   mips_sat_u_w,   mips_shf_b,   mips_shf_h,   mips_shf_w,   mips_shilo,   mips_shll_ph,   mips_shll_qb,   mips_shll_s_ph,   mips_shll_s_w,   mips_shra_ph,   mips_shra_qb,   mips_shra_r_ph,   mips_shra_r_qb,   mips_shra_r_w,   mips_shrl_ph,   mips_shrl_qb,   mips_sld_b,   mips_sld_d,   mips_sld_h,   mips_sld_w,   mips_sldi_b,   mips_sldi_d,   mips_sldi_h,   mips_sldi_w,   mips_sll_b,   mips_sll_d,   mips_sll_h,   mips_sll_w,   mips_slli_b,   mips_slli_d,   mips_slli_h,   mips_slli_w,   mips_splat_b,   mips_splat_d,   mips_splat_h,   mips_splat_w,   mips_splati_b,   mips_splati_d,   mips_splati_h,   mips_splati_w,   mips_sra_b,   mips_sra_d,   mips_sra_h,   mips_sra_w,   mips_srai_b,   mips_srai_d,   mips_srai_h,   mips_srai_w,   mips_srar_b,   mips_srar_d,   mips_srar_h,   mips_srar_w,   mips_srari_b,   mips_srari_d,   mips_srari_h,   mips_srari_w,   mips_srl_b,   mips_srl_d,   mips_srl_h,   mips_srl_w,   mips_srli_b,   mips_srli_d,   mips_srli_h,   mips_srli_w,   mips_srlr_b,   mips_srlr_d,   mips_srlr_h,   mips_srlr_w,   mips_srlri_b,   mips_srlri_d,   mips_srlri_h,   mips_srlri_w,   mips_st_b,   mips_st_d,   mips_st_h,   mips_st_w,   mips_stx_b,   mips_stx_d,   mips_stx_h,   mips_stx_w,   mips_subq_ph,   mips_subq_s_ph,   mips_subq_s_w,   mips_subqh_ph,   mips_subqh_r_ph,   mips_subqh_r_w,   mips_subqh_w,   mips_subs_s_b,   mips_subs_s_d,   mips_subs_s_h,   mips_subs_s_w,   mips_subs_u_b,   mips_subs_u_d,   mips_subs_u_h,   mips_subs_u_w,   mips_subsus_u_b,   mips_subsus_u_d,   mips_subsus_u_h,   mips_subsus_u_w,   mips_subsuu_s_b,   mips_subsuu_s_d,   mips_subsuu_s_h,   mips_subsuu_s_w,   mips_subu_ph,   mips_subu_qb,   mips_subu_s_ph,   mips_subu_s_qb,   mips_subuh_qb,   mips_subuh_r_qb,   mips_subv_b,   mips_subv_d,   mips_subv_h,   mips_subv_w,   mips_subvi_b,   mips_subvi_d,   mips_subvi_h,   mips_subvi_w,   mips_vshf_b,   mips_vshf_d,   mips_vshf_h,   mips_vshf_w,   mips_wrdsp,   mips_xor_v,   mips_xori_b,   nearbyint,   nvvm_abs_i,   nvvm_abs_ll,   nvvm_add_rm_d,   nvvm_add_rm_f,   nvvm_add_rm_ftz_f,   nvvm_add_rn_d,   nvvm_add_rn_f,   nvvm_add_rn_ftz_f,   nvvm_add_rp_d,   nvvm_add_rp_f,   nvvm_add_rp_ftz_f,   nvvm_add_rz_d,   nvvm_add_rz_f,   nvvm_add_rz_ftz_f,   nvvm_atomic_load_add_f32,   nvvm_atomic_load_dec_32,   nvvm_atomic_load_inc_32,   nvvm_barrier0,   nvvm_barrier0_and,   nvvm_barrier0_or,   nvvm_barrier0_popc,   nvvm_bitcast_d2ll,   nvvm_bitcast_f2i,   nvvm_bitcast_i2f,   nvvm_bitcast_ll2d,   nvvm_brev32,   nvvm_brev64,   nvvm_ceil_d,   nvvm_ceil_f,   nvvm_ceil_ftz_f,   nvvm_clz_i,   nvvm_clz_ll,   nvvm_compiler_error,   nvvm_compiler_warn,   nvvm_cos_approx_f,   nvvm_cos_approx_ftz_f,   nvvm_d2f_rm,   nvvm_d2f_rm_ftz,   nvvm_d2f_rn,   nvvm_d2f_rn_ftz,   nvvm_d2f_rp,   nvvm_d2f_rp_ftz,   nvvm_d2f_rz,   nvvm_d2f_rz_ftz,   nvvm_d2i_hi,   nvvm_d2i_lo,   nvvm_d2i_rm,   nvvm_d2i_rn,   nvvm_d2i_rp,   nvvm_d2i_rz,   nvvm_d2ll_rm,   nvvm_d2ll_rn,   nvvm_d2ll_rp,   nvvm_d2ll_rz,   nvvm_d2ui_rm,   nvvm_d2ui_rn,   nvvm_d2ui_rp,   nvvm_d2ui_rz,   nvvm_d2ull_rm,   nvvm_d2ull_rn,   nvvm_d2ull_rp,   nvvm_d2ull_rz,   nvvm_div_approx_f,   nvvm_div_approx_ftz_f,   nvvm_div_rm_d,   nvvm_div_rm_f,   nvvm_div_rm_ftz_f,   nvvm_div_rn_d,   nvvm_div_rn_f,   nvvm_div_rn_ftz_f,   nvvm_div_rp_d,   nvvm_div_rp_f,   nvvm_div_rp_ftz_f,   nvvm_div_rz_d,   nvvm_div_rz_f,   nvvm_div_rz_ftz_f,   nvvm_ex2_approx_d,   nvvm_ex2_approx_f,   nvvm_ex2_approx_ftz_f,   nvvm_f2h_rn,   nvvm_f2h_rn_ftz,   nvvm_f2i_rm,   nvvm_f2i_rm_ftz,   nvvm_f2i_rn,   nvvm_f2i_rn_ftz,   nvvm_f2i_rp,   nvvm_f2i_rp_ftz,   nvvm_f2i_rz,   nvvm_f2i_rz_ftz,   nvvm_f2ll_rm,   nvvm_f2ll_rm_ftz,   nvvm_f2ll_rn,   nvvm_f2ll_rn_ftz,   nvvm_f2ll_rp,   nvvm_f2ll_rp_ftz,   nvvm_f2ll_rz,   nvvm_f2ll_rz_ftz,   nvvm_f2ui_rm,   nvvm_f2ui_rm_ftz,   nvvm_f2ui_rn,   nvvm_f2ui_rn_ftz,   nvvm_f2ui_rp,   nvvm_f2ui_rp_ftz,   nvvm_f2ui_rz,   nvvm_f2ui_rz_ftz,   nvvm_f2ull_rm,   nvvm_f2ull_rm_ftz,   nvvm_f2ull_rn,   nvvm_f2ull_rn_ftz,   nvvm_f2ull_rp,   nvvm_f2ull_rp_ftz,   nvvm_f2ull_rz,   nvvm_f2ull_rz_ftz,   nvvm_fabs_d,   nvvm_fabs_f,   nvvm_fabs_ftz_f,   nvvm_floor_d,   nvvm_floor_f,   nvvm_floor_ftz_f,   nvvm_fma_rm_d,   nvvm_fma_rm_f,   nvvm_fma_rm_ftz_f,   nvvm_fma_rn_d,   nvvm_fma_rn_f,   nvvm_fma_rn_ftz_f,   nvvm_fma_rp_d,   nvvm_fma_rp_f,   nvvm_fma_rp_ftz_f,   nvvm_fma_rz_d,   nvvm_fma_rz_f,   nvvm_fma_rz_ftz_f,   nvvm_fmax_d,   nvvm_fmax_f,   nvvm_fmax_ftz_f,   nvvm_fmin_d,   nvvm_fmin_f,   nvvm_fmin_ftz_f,   nvvm_h2f,   nvvm_i2d_rm,   nvvm_i2d_rn,   nvvm_i2d_rp,   nvvm_i2d_rz,   nvvm_i2f_rm,   nvvm_i2f_rn,   nvvm_i2f_rp,   nvvm_i2f_rz,   nvvm_ldg_global_f,   nvvm_ldg_global_i,   nvvm_ldg_global_p,   nvvm_ldu_global_f,   nvvm_ldu_global_i,   nvvm_ldu_global_p,   nvvm_lg2_approx_d,   nvvm_lg2_approx_f,   nvvm_lg2_approx_ftz_f,   nvvm_ll2d_rm,   nvvm_ll2d_rn,   nvvm_ll2d_rp,   nvvm_ll2d_rz,   nvvm_ll2f_rm,   nvvm_ll2f_rn,   nvvm_ll2f_rp,   nvvm_ll2f_rz,   nvvm_lohi_i2d,   nvvm_max_i,   nvvm_max_ll,   nvvm_max_ui,   nvvm_max_ull,   nvvm_membar_cta,   nvvm_membar_gl,   nvvm_membar_sys,   nvvm_min_i,   nvvm_min_ll,   nvvm_min_ui,   nvvm_min_ull,   nvvm_move_double,   nvvm_move_float,   nvvm_move_i16,   nvvm_move_i32,   nvvm_move_i64,   nvvm_move_ptr,   nvvm_mul24_i,   nvvm_mul24_ui,   nvvm_mul_rm_d,   nvvm_mul_rm_f,   nvvm_mul_rm_ftz_f,   nvvm_mul_rn_d,   nvvm_mul_rn_f,   nvvm_mul_rn_ftz_f,   nvvm_mul_rp_d,   nvvm_mul_rp_f,   nvvm_mul_rp_ftz_f,   nvvm_mul_rz_d,   nvvm_mul_rz_f,   nvvm_mul_rz_ftz_f,   nvvm_mulhi_i,   nvvm_mulhi_ll,   nvvm_mulhi_ui,   nvvm_mulhi_ull,   nvvm_popc_i,   nvvm_popc_ll,   nvvm_prmt,   nvvm_ptr_constant_to_gen,   nvvm_ptr_gen_to_constant,   nvvm_ptr_gen_to_global,   nvvm_ptr_gen_to_local,   nvvm_ptr_gen_to_param,   nvvm_ptr_gen_to_shared,   nvvm_ptr_global_to_gen,   nvvm_ptr_local_to_gen,   nvvm_ptr_shared_to_gen,   nvvm_rcp_approx_ftz_d,   nvvm_rcp_rm_d,   nvvm_rcp_rm_f,   nvvm_rcp_rm_ftz_f,   nvvm_rcp_rn_d,   nvvm_rcp_rn_f,   nvvm_rcp_rn_ftz_f,   nvvm_rcp_rp_d,   nvvm_rcp_rp_f,   nvvm_rcp_rp_ftz_f,   nvvm_rcp_rz_d,   nvvm_rcp_rz_f,   nvvm_rcp_rz_ftz_f,   nvvm_read_ptx_sreg_ctaid_x,   nvvm_read_ptx_sreg_ctaid_y,   nvvm_read_ptx_sreg_ctaid_z,   nvvm_read_ptx_sreg_nctaid_x,   nvvm_read_ptx_sreg_nctaid_y,   nvvm_read_ptx_sreg_nctaid_z,   nvvm_read_ptx_sreg_ntid_x,   nvvm_read_ptx_sreg_ntid_y,   nvvm_read_ptx_sreg_ntid_z,   nvvm_read_ptx_sreg_tid_x,   nvvm_read_ptx_sreg_tid_y,   nvvm_read_ptx_sreg_tid_z,   nvvm_read_ptx_sreg_warpsize,   nvvm_round_d,   nvvm_round_f,   nvvm_round_ftz_f,   nvvm_rsqrt_approx_d,   nvvm_rsqrt_approx_f,   nvvm_rsqrt_approx_ftz_f,   nvvm_sad_i,   nvvm_sad_ui,   nvvm_saturate_d,   nvvm_saturate_f,   nvvm_saturate_ftz_f,   nvvm_sin_approx_f,   nvvm_sin_approx_ftz_f,   nvvm_sqrt_approx_f,   nvvm_sqrt_approx_ftz_f,   nvvm_sqrt_f,   nvvm_sqrt_rm_d,   nvvm_sqrt_rm_f,   nvvm_sqrt_rm_ftz_f,   nvvm_sqrt_rn_d,   nvvm_sqrt_rn_f,   nvvm_sqrt_rn_ftz_f,   nvvm_sqrt_rp_d,   nvvm_sqrt_rp_f,   nvvm_sqrt_rp_ftz_f,   nvvm_sqrt_rz_d,   nvvm_sqrt_rz_f,   nvvm_sqrt_rz_ftz_f,   nvvm_trunc_d,   nvvm_trunc_f,   nvvm_trunc_ftz_f,   nvvm_ui2d_rm,   nvvm_ui2d_rn,   nvvm_ui2d_rp,   nvvm_ui2d_rz,   nvvm_ui2f_rm,   nvvm_ui2f_rn,   nvvm_ui2f_rp,   nvvm_ui2f_rz,   nvvm_ull2d_rm,   nvvm_ull2d_rn,   nvvm_ull2d_rp,   nvvm_ull2d_rz,   nvvm_ull2f_rm,   nvvm_ull2f_rn,   nvvm_ull2f_rp,   nvvm_ull2f_rz,   objectsize,   pcmarker,   pow,   powi,   ppc_altivec_dss,   ppc_altivec_dssall,   ppc_altivec_dst,   ppc_altivec_dstst,   ppc_altivec_dststt,   ppc_altivec_dstt,   ppc_altivec_lvebx,   ppc_altivec_lvehx,   ppc_altivec_lvewx,   ppc_altivec_lvsl,   ppc_altivec_lvsr,   ppc_altivec_lvx,   ppc_altivec_lvxl,   ppc_altivec_mfvscr,   ppc_altivec_mtvscr,   ppc_altivec_stvebx,   ppc_altivec_stvehx,   ppc_altivec_stvewx,   ppc_altivec_stvx,   ppc_altivec_stvxl,   ppc_altivec_vaddcuw,   ppc_altivec_vaddsbs,   ppc_altivec_vaddshs,   ppc_altivec_vaddsws,   ppc_altivec_vaddubs,   ppc_altivec_vadduhs,   ppc_altivec_vadduws,   ppc_altivec_vavgsb,   ppc_altivec_vavgsh,   ppc_altivec_vavgsw,   ppc_altivec_vavgub,   ppc_altivec_vavguh,   ppc_altivec_vavguw,   ppc_altivec_vcfsx,   ppc_altivec_vcfux,   ppc_altivec_vcmpbfp,   ppc_altivec_vcmpbfp_p,   ppc_altivec_vcmpeqfp,   ppc_altivec_vcmpeqfp_p,   ppc_altivec_vcmpequb,   ppc_altivec_vcmpequb_p,   ppc_altivec_vcmpequh,   ppc_altivec_vcmpequh_p,   ppc_altivec_vcmpequw,   ppc_altivec_vcmpequw_p,   ppc_altivec_vcmpgefp,   ppc_altivec_vcmpgefp_p,   ppc_altivec_vcmpgtfp,   ppc_altivec_vcmpgtfp_p,   ppc_altivec_vcmpgtsb,   ppc_altivec_vcmpgtsb_p,   ppc_altivec_vcmpgtsh,   ppc_altivec_vcmpgtsh_p,   ppc_altivec_vcmpgtsw,   ppc_altivec_vcmpgtsw_p,   ppc_altivec_vcmpgtub,   ppc_altivec_vcmpgtub_p,   ppc_altivec_vcmpgtuh,   ppc_altivec_vcmpgtuh_p,   ppc_altivec_vcmpgtuw,   ppc_altivec_vcmpgtuw_p,   ppc_altivec_vctsxs,   ppc_altivec_vctuxs,   ppc_altivec_vexptefp,   ppc_altivec_vlogefp,   ppc_altivec_vmaddfp,   ppc_altivec_vmaxfp,   ppc_altivec_vmaxsb,   ppc_altivec_vmaxsh,   ppc_altivec_vmaxsw,   ppc_altivec_vmaxub,   ppc_altivec_vmaxuh,   ppc_altivec_vmaxuw,   ppc_altivec_vmhaddshs,   ppc_altivec_vmhraddshs,   ppc_altivec_vminfp,   ppc_altivec_vminsb,   ppc_altivec_vminsh,   ppc_altivec_vminsw,   ppc_altivec_vminub,   ppc_altivec_vminuh,   ppc_altivec_vminuw,   ppc_altivec_vmladduhm,   ppc_altivec_vmsummbm,   ppc_altivec_vmsumshm,   ppc_altivec_vmsumshs,   ppc_altivec_vmsumubm,   ppc_altivec_vmsumuhm,   ppc_altivec_vmsumuhs,   ppc_altivec_vmulesb,   ppc_altivec_vmulesh,   ppc_altivec_vmuleub,   ppc_altivec_vmuleuh,   ppc_altivec_vmulosb,   ppc_altivec_vmulosh,   ppc_altivec_vmuloub,   ppc_altivec_vmulouh,   ppc_altivec_vnmsubfp,   ppc_altivec_vperm,   ppc_altivec_vpkpx,   ppc_altivec_vpkshss,   ppc_altivec_vpkshus,   ppc_altivec_vpkswss,   ppc_altivec_vpkswus,   ppc_altivec_vpkuhus,   ppc_altivec_vpkuwus,   ppc_altivec_vrefp,   ppc_altivec_vrfim,   ppc_altivec_vrfin,   ppc_altivec_vrfip,   ppc_altivec_vrfiz,   ppc_altivec_vrlb,   ppc_altivec_vrlh,   ppc_altivec_vrlw,   ppc_altivec_vrsqrtefp,   ppc_altivec_vsel,   ppc_altivec_vsl,   ppc_altivec_vslb,   ppc_altivec_vslh,   ppc_altivec_vslo,   ppc_altivec_vslw,   ppc_altivec_vsr,   ppc_altivec_vsrab,   ppc_altivec_vsrah,   ppc_altivec_vsraw,   ppc_altivec_vsrb,   ppc_altivec_vsrh,   ppc_altivec_vsro,   ppc_altivec_vsrw,   ppc_altivec_vsubcuw,   ppc_altivec_vsubsbs,   ppc_altivec_vsubshs,   ppc_altivec_vsubsws,   ppc_altivec_vsububs,   ppc_altivec_vsubuhs,   ppc_altivec_vsubuws,   ppc_altivec_vsum2sws,   ppc_altivec_vsum4sbs,   ppc_altivec_vsum4shs,   ppc_altivec_vsum4ubs,   ppc_altivec_vsumsws,   ppc_altivec_vupkhpx,   ppc_altivec_vupkhsb,   ppc_altivec_vupkhsh,   ppc_altivec_vupklpx,   ppc_altivec_vupklsb,   ppc_altivec_vupklsh,   ppc_dcba,   ppc_dcbf,   ppc_dcbi,   ppc_dcbst,   ppc_dcbt,   ppc_dcbtst,   ppc_dcbz,   ppc_dcbzl,   ppc_is_decremented_ctr_nonzero,   ppc_mtctr,   ppc_sync,   prefetch,   ptr_annotation,   ptx_bar_sync,   ptx_read_clock,   ptx_read_clock64,   ptx_read_ctaid_w,   ptx_read_ctaid_x,   ptx_read_ctaid_y,   ptx_read_ctaid_z,   ptx_read_gridid,   ptx_read_laneid,   ptx_read_lanemask_eq,   ptx_read_lanemask_ge,   ptx_read_lanemask_gt,   ptx_read_lanemask_le,   ptx_read_lanemask_lt,   ptx_read_nctaid_w,   ptx_read_nctaid_x,   ptx_read_nctaid_y,   ptx_read_nctaid_z,   ptx_read_nsmid,   ptx_read_ntid_w,   ptx_read_ntid_x,   ptx_read_ntid_y,   ptx_read_ntid_z,   ptx_read_nwarpid,   ptx_read_pm0,   ptx_read_pm1,   ptx_read_pm2,   ptx_read_pm3,   ptx_read_smid,   ptx_read_tid_w,   ptx_read_tid_x,   ptx_read_tid_y,   ptx_read_tid_z,   ptx_read_warpid,   r600_read_global_size_x,   r600_read_global_size_y,   r600_read_global_size_z,   r600_read_local_size_x,   r600_read_local_size_y,   r600_read_local_size_z,   r600_read_ngroups_x,   r600_read_ngroups_y,   r600_read_ngroups_z,   r600_read_tgid_x,   r600_read_tgid_y,   r600_read_tgid_z,   r600_read_tidig_x,   r600_read_tidig_y,   r600_read_tidig_z,   readcyclecounter,   returnaddress,   rint,   round,   sadd_with_overflow,   setjmp,   siglongjmp,   sigsetjmp,   sin,   smul_with_overflow,   sqrt,   ssub_with_overflow,   stackprotector,   stackprotectorcheck,   stackrestore,   stacksave,   trap,   trunc,   uadd_with_overflow,   umul_with_overflow,   usub_with_overflow,   vacopy,   vaend,   var_annotation,   vastart,   x86_3dnow_pavgusb,   x86_3dnow_pf2id,   x86_3dnow_pfacc,   x86_3dnow_pfadd,   x86_3dnow_pfcmpeq,   x86_3dnow_pfcmpge,   x86_3dnow_pfcmpgt,   x86_3dnow_pfmax,   x86_3dnow_pfmin,   x86_3dnow_pfmul,   x86_3dnow_pfrcp,   x86_3dnow_pfrcpit1,   x86_3dnow_pfrcpit2,   x86_3dnow_pfrsqit1,   x86_3dnow_pfrsqrt,   x86_3dnow_pfsub,   x86_3dnow_pfsubr,   x86_3dnow_pi2fd,   x86_3dnow_pmulhrw,   x86_3dnowa_pf2iw,   x86_3dnowa_pfnacc,   x86_3dnowa_pfpnacc,   x86_3dnowa_pi2fw,   x86_3dnowa_pswapd,   x86_aesni_aesdec,   x86_aesni_aesdeclast,   x86_aesni_aesenc,   x86_aesni_aesenclast,   x86_aesni_aesimc,   x86_aesni_aeskeygenassist,   x86_avx2_gather_d_d,   x86_avx2_gather_d_d_256,   x86_avx2_gather_d_pd,   x86_avx2_gather_d_pd_256,   x86_avx2_gather_d_ps,   x86_avx2_gather_d_ps_256,   x86_avx2_gather_d_q,   x86_avx2_gather_d_q_256,   x86_avx2_gather_q_d,   x86_avx2_gather_q_d_256,   x86_avx2_gather_q_pd,   x86_avx2_gather_q_pd_256,   x86_avx2_gather_q_ps,   x86_avx2_gather_q_ps_256,   x86_avx2_gather_q_q,   x86_avx2_gather_q_q_256,   x86_avx2_maskload_d,   x86_avx2_maskload_d_256,   x86_avx2_maskload_q,   x86_avx2_maskload_q_256,   x86_avx2_maskstore_d,   x86_avx2_maskstore_d_256,   x86_avx2_maskstore_q,   x86_avx2_maskstore_q_256,   x86_avx2_movntdqa,   x86_avx2_mpsadbw,   x86_avx2_pabs_b,   x86_avx2_pabs_d,   x86_avx2_pabs_w,   x86_avx2_packssdw,   x86_avx2_packsswb,   x86_avx2_packusdw,   x86_avx2_packuswb,   x86_avx2_padds_b,   x86_avx2_padds_w,   x86_avx2_paddus_b,   x86_avx2_paddus_w,   x86_avx2_pavg_b,   x86_avx2_pavg_w,   x86_avx2_pblendd_128,   x86_avx2_pblendd_256,   x86_avx2_pblendvb,   x86_avx2_pblendw,   x86_avx2_pbroadcastb_128,   x86_avx2_pbroadcastb_256,   x86_avx2_pbroadcastd_128,   x86_avx2_pbroadcastd_256,   x86_avx2_pbroadcastq_128,   x86_avx2_pbroadcastq_256,   x86_avx2_pbroadcastw_128,   x86_avx2_pbroadcastw_256,   x86_avx2_permd,   x86_avx2_permps,   x86_avx2_phadd_d,   x86_avx2_phadd_sw,   x86_avx2_phadd_w,   x86_avx2_phsub_d,   x86_avx2_phsub_sw,   x86_avx2_phsub_w,   x86_avx2_pmadd_ub_sw,   x86_avx2_pmadd_wd,   x86_avx2_pmaxs_b,   x86_avx2_pmaxs_d,   x86_avx2_pmaxs_w,   x86_avx2_pmaxu_b,   x86_avx2_pmaxu_d,   x86_avx2_pmaxu_w,   x86_avx2_pmins_b,   x86_avx2_pmins_d,   x86_avx2_pmins_w,   x86_avx2_pminu_b,   x86_avx2_pminu_d,   x86_avx2_pminu_w,   x86_avx2_pmovmskb,   x86_avx2_pmovsxbd,   x86_avx2_pmovsxbq,   x86_avx2_pmovsxbw,   x86_avx2_pmovsxdq,   x86_avx2_pmovsxwd,   x86_avx2_pmovsxwq,   x86_avx2_pmovzxbd,   x86_avx2_pmovzxbq,   x86_avx2_pmovzxbw,   x86_avx2_pmovzxdq,   x86_avx2_pmovzxwd,   x86_avx2_pmovzxwq,   x86_avx2_pmul_dq,   x86_avx2_pmul_hr_sw,   x86_avx2_pmulh_w,   x86_avx2_pmulhu_w,   x86_avx2_pmulu_dq,   x86_avx2_psad_bw,   x86_avx2_pshuf_b,   x86_avx2_psign_b,   x86_avx2_psign_d,   x86_avx2_psign_w,   x86_avx2_psll_d,   x86_avx2_psll_dq,   x86_avx2_psll_dq_bs,   x86_avx2_psll_q,   x86_avx2_psll_w,   x86_avx2_pslli_d,   x86_avx2_pslli_q,   x86_avx2_pslli_w,   x86_avx2_psllv_d,   x86_avx2_psllv_d_256,   x86_avx2_psllv_q,   x86_avx2_psllv_q_256,   x86_avx2_psra_d,   x86_avx2_psra_w,   x86_avx2_psrai_d,   x86_avx2_psrai_w,   x86_avx2_psrav_d,   x86_avx2_psrav_d_256,   x86_avx2_psrl_d,   x86_avx2_psrl_dq,   x86_avx2_psrl_dq_bs,   x86_avx2_psrl_q,   x86_avx2_psrl_w,   x86_avx2_psrli_d,   x86_avx2_psrli_q,   x86_avx2_psrli_w,   x86_avx2_psrlv_d,   x86_avx2_psrlv_d_256,   x86_avx2_psrlv_q,   x86_avx2_psrlv_q_256,   x86_avx2_psubs_b,   x86_avx2_psubs_w,   x86_avx2_psubus_b,   x86_avx2_psubus_w,   x86_avx2_vbroadcast_sd_pd_256,   x86_avx2_vbroadcast_ss_ps,   x86_avx2_vbroadcast_ss_ps_256,   x86_avx2_vbroadcasti128,   x86_avx2_vextracti128,   x86_avx2_vinserti128,   x86_avx2_vperm2i128,   x86_avx512_and_pi,   x86_avx512_cmpeq_pi_512,   x86_avx512_cvt_ps2dq_512,   x86_avx512_cvtdq2_ps_512,   x86_avx512_cvtsd2usi,   x86_avx512_cvtsd2usi64,   x86_avx512_cvtss2usi,   x86_avx512_cvtss2usi64,   x86_avx512_cvttsd2usi,   x86_avx512_cvttsd2usi64,   x86_avx512_cvttss2usi,   x86_avx512_cvttss2usi64,   x86_avx512_cvtusi2sd,   x86_avx512_cvtusi2ss,   x86_avx512_cvtusi642sd,   x86_avx512_cvtusi642ss,   x86_avx512_gather_dpd_512,   x86_avx512_gather_dpd_mask_512,   x86_avx512_gather_dpi_512,   x86_avx512_gather_dpi_mask_512,   x86_avx512_gather_dpq_512,   x86_avx512_gather_dpq_mask_512,   x86_avx512_gather_dps_512,   x86_avx512_gather_dps_mask_512,   x86_avx512_gather_qpd_512,   x86_avx512_gather_qpd_mask_512,   x86_avx512_gather_qpi_512,   x86_avx512_gather_qpi_mask_512,   x86_avx512_gather_qpq_512,   x86_avx512_gather_qpq_mask_512,   x86_avx512_gather_qps_512,   x86_avx512_gather_qps_mask_512,   x86_avx512_kortestc,   x86_avx512_kortestz,   x86_avx512_max_pd_512,   x86_avx512_max_ps_512,   x86_avx512_min_pd_512,   x86_avx512_min_ps_512,   x86_avx512_mskblend_ps_512,   x86_avx512_pmovzxbd,   x86_avx512_pmovzxbq,   x86_avx512_pmovzxdq,   x86_avx512_pmovzxwd,   x86_avx512_pmovzxwq,   x86_avx512_psll_dq,   x86_avx512_psll_dq_bs,   x86_avx512_psrl_dq,   x86_avx512_psrl_dq_bs,   x86_avx512_rcp14_pd_512,   x86_avx512_rcp14_ps_512,   x86_avx512_rcp14_sd,   x86_avx512_rcp14_ss,   x86_avx512_rndscale_pd_512,   x86_avx512_rndscale_ps_512,   x86_avx512_rndscale_sd,   x86_avx512_rndscale_ss,   x86_avx512_rsqrt14_pd_512,   x86_avx512_rsqrt14_ps_512,   x86_avx512_rsqrt14_sd,   x86_avx512_rsqrt14_ss,   x86_avx512_scatter_dpd_512,   x86_avx512_scatter_dpd_mask_512,   x86_avx512_scatter_dpi_512,   x86_avx512_scatter_dpi_mask_512,   x86_avx512_scatter_dpq_512,   x86_avx512_scatter_dpq_mask_512,   x86_avx512_scatter_dps_512,   x86_avx512_scatter_dps_mask_512,   x86_avx512_scatter_qpd_512,   x86_avx512_scatter_qpd_mask_512,   x86_avx512_scatter_qpi_512,   x86_avx512_scatter_qpi_mask_512,   x86_avx512_scatter_qpq_512,   x86_avx512_scatter_qpq_mask_512,   x86_avx512_scatter_qps_512,   x86_avx512_scatter_qps_mask_512,   x86_avx512_sqrt_pd_512,   x86_avx512_sqrt_ps_512,   x86_avx512_sqrt_sd,   x86_avx512_sqrt_ss,   x86_avx512_vbroadcast_sd_512,   x86_avx512_vbroadcast_sd_pd_512,   x86_avx512_vbroadcast_ss_512,   x86_avx512_vbroadcast_ss_ps_512,   x86_avx_addsub_pd_256,   x86_avx_addsub_ps_256,   x86_avx_blend_pd_256,   x86_avx_blend_ps_256,   x86_avx_blendv_pd_256,   x86_avx_blendv_ps_256,   x86_avx_cmp_pd_256,   x86_avx_cmp_ps_256,   x86_avx_cvt_pd2_ps_256,   x86_avx_cvt_pd2dq_256,   x86_avx_cvt_ps2_pd_256,   x86_avx_cvt_ps2dq_256,   x86_avx_cvtdq2_pd_256,   x86_avx_cvtdq2_ps_256,   x86_avx_cvtt_pd2dq_256,   x86_avx_cvtt_ps2dq_256,   x86_avx_dp_ps_256,   x86_avx_hadd_pd_256,   x86_avx_hadd_ps_256,   x86_avx_hsub_pd_256,   x86_avx_hsub_ps_256,   x86_avx_ldu_dq_256,   x86_avx_maskload_pd,   x86_avx_maskload_pd_256,   x86_avx_maskload_ps,   x86_avx_maskload_ps_256,   x86_avx_maskstore_pd,   x86_avx_maskstore_pd_256,   x86_avx_maskstore_ps,   x86_avx_maskstore_ps_256,   x86_avx_max_pd_256,   x86_avx_max_ps_256,   x86_avx_min_pd_256,   x86_avx_min_ps_256,   x86_avx_movmsk_pd_256,   x86_avx_movmsk_ps_256,   x86_avx_ptestc_256,   x86_avx_ptestnzc_256,   x86_avx_ptestz_256,   x86_avx_rcp_ps_256,   x86_avx_round_pd_256,   x86_avx_round_ps_256,   x86_avx_rsqrt_ps_256,   x86_avx_sqrt_pd_256,   x86_avx_sqrt_ps_256,   x86_avx_storeu_dq_256,   x86_avx_storeu_pd_256,   x86_avx_storeu_ps_256,   x86_avx_vbroadcast_sd_256,   x86_avx_vbroadcast_ss,   x86_avx_vbroadcast_ss_256,   x86_avx_vbroadcastf128_pd_256,   x86_avx_vbroadcastf128_ps_256,   x86_avx_vextractf128_pd_256,   x86_avx_vextractf128_ps_256,   x86_avx_vextractf128_si_256,   x86_avx_vinsertf128_pd_256,   x86_avx_vinsertf128_ps_256,   x86_avx_vinsertf128_si_256,   x86_avx_vperm2f128_pd_256,   x86_avx_vperm2f128_ps_256,   x86_avx_vperm2f128_si_256,   x86_avx_vpermilvar_pd,   x86_avx_vpermilvar_pd_256,   x86_avx_vpermilvar_ps,   x86_avx_vpermilvar_ps_256,   x86_avx_vtestc_pd,   x86_avx_vtestc_pd_256,   x86_avx_vtestc_ps,   x86_avx_vtestc_ps_256,   x86_avx_vtestnzc_pd,   x86_avx_vtestnzc_pd_256,   x86_avx_vtestnzc_ps,   x86_avx_vtestnzc_ps_256,   x86_avx_vtestz_pd,   x86_avx_vtestz_pd_256,   x86_avx_vtestz_ps,   x86_avx_vtestz_ps_256,   x86_avx_vzeroall,   x86_avx_vzeroupper,   x86_bmi_bextr_32,   x86_bmi_bextr_64,   x86_bmi_bzhi_32,   x86_bmi_bzhi_64,   x86_bmi_pdep_32,   x86_bmi_pdep_64,   x86_bmi_pext_32,   x86_bmi_pext_64,   x86_fma_vfmadd_pd,   x86_fma_vfmadd_pd_256,   x86_fma_vfmadd_ps,   x86_fma_vfmadd_ps_256,   x86_fma_vfmadd_sd,   x86_fma_vfmadd_ss,   x86_fma_vfmaddsub_pd,   x86_fma_vfmaddsub_pd_256,   x86_fma_vfmaddsub_ps,   x86_fma_vfmaddsub_ps_256,   x86_fma_vfmsub_pd,   x86_fma_vfmsub_pd_256,   x86_fma_vfmsub_ps,   x86_fma_vfmsub_ps_256,   x86_fma_vfmsub_sd,   x86_fma_vfmsub_ss,   x86_fma_vfmsubadd_pd,   x86_fma_vfmsubadd_pd_256,   x86_fma_vfmsubadd_ps,   x86_fma_vfmsubadd_ps_256,   x86_fma_vfnmadd_pd,   x86_fma_vfnmadd_pd_256,   x86_fma_vfnmadd_ps,   x86_fma_vfnmadd_ps_256,   x86_fma_vfnmadd_sd,   x86_fma_vfnmadd_ss,   x86_fma_vfnmsub_pd,   x86_fma_vfnmsub_pd_256,   x86_fma_vfnmsub_ps,   x86_fma_vfnmsub_ps_256,   x86_fma_vfnmsub_sd,   x86_fma_vfnmsub_ss,   x86_int,   x86_int2mask_v16i1,   x86_kadd_v16i1,   x86_kand_v16i1,   x86_kandn_v16i1,   x86_knot_v16i1,   x86_kor_v16i1,   x86_kunpck_v16i1,   x86_kxnor_v16i1,   x86_kxor_v16i1,   x86_mask2int_v16i1,   x86_mmx_emms,   x86_mmx_femms,   x86_mmx_maskmovq,   x86_mmx_movnt_dq,   x86_mmx_packssdw,   x86_mmx_packsswb,   x86_mmx_packuswb,   x86_mmx_padd_b,   x86_mmx_padd_d,   x86_mmx_padd_q,   x86_mmx_padd_w,   x86_mmx_padds_b,   x86_mmx_padds_w,   x86_mmx_paddus_b,   x86_mmx_paddus_w,   x86_mmx_palignr_b,   x86_mmx_pand,   x86_mmx_pandn,   x86_mmx_pavg_b,   x86_mmx_pavg_w,   x86_mmx_pcmpeq_b,   x86_mmx_pcmpeq_d,   x86_mmx_pcmpeq_w,   x86_mmx_pcmpgt_b,   x86_mmx_pcmpgt_d,   x86_mmx_pcmpgt_w,   x86_mmx_pextr_w,   x86_mmx_pinsr_w,   x86_mmx_pmadd_wd,   x86_mmx_pmaxs_w,   x86_mmx_pmaxu_b,   x86_mmx_pmins_w,   x86_mmx_pminu_b,   x86_mmx_pmovmskb,   x86_mmx_pmulh_w,   x86_mmx_pmulhu_w,   x86_mmx_pmull_w,   x86_mmx_pmulu_dq,   x86_mmx_por,   x86_mmx_psad_bw,   x86_mmx_psll_d,   x86_mmx_psll_q,   x86_mmx_psll_w,   x86_mmx_pslli_d,   x86_mmx_pslli_q,   x86_mmx_pslli_w,   x86_mmx_psra_d,   x86_mmx_psra_w,   x86_mmx_psrai_d,   x86_mmx_psrai_w,   x86_mmx_psrl_d,   x86_mmx_psrl_q,   x86_mmx_psrl_w,   x86_mmx_psrli_d,   x86_mmx_psrli_q,   x86_mmx_psrli_w,   x86_mmx_psub_b,   x86_mmx_psub_d,   x86_mmx_psub_q,   x86_mmx_psub_w,   x86_mmx_psubs_b,   x86_mmx_psubs_w,   x86_mmx_psubus_b,   x86_mmx_psubus_w,   x86_mmx_punpckhbw,   x86_mmx_punpckhdq,   x86_mmx_punpckhwd,   x86_mmx_punpcklbw,   x86_mmx_punpckldq,   x86_mmx_punpcklwd,   x86_mmx_pxor,   x86_pclmulqdq,   x86_rdfsbase_32,   x86_rdfsbase_64,   x86_rdgsbase_32,   x86_rdgsbase_64,   x86_rdrand_16,   x86_rdrand_32,   x86_rdrand_64,   x86_rdseed_16,   x86_rdseed_32,   x86_rdseed_64,   x86_sha1msg1,   x86_sha1msg2,   x86_sha1nexte,   x86_sha1rnds4,   x86_sha256msg1,   x86_sha256msg2,   x86_sha256rnds2,   x86_sse2_add_sd,   x86_sse2_clflush,   x86_sse2_cmp_pd,   x86_sse2_cmp_sd,   x86_sse2_comieq_sd,   x86_sse2_comige_sd,   x86_sse2_comigt_sd,   x86_sse2_comile_sd,   x86_sse2_comilt_sd,   x86_sse2_comineq_sd,   x86_sse2_cvtdq2pd,   x86_sse2_cvtdq2ps,   x86_sse2_cvtpd2dq,   x86_sse2_cvtpd2ps,   x86_sse2_cvtps2dq,   x86_sse2_cvtps2pd,   x86_sse2_cvtsd2si,   x86_sse2_cvtsd2si64,   x86_sse2_cvtsd2ss,   x86_sse2_cvtsi2sd,   x86_sse2_cvtsi642sd,   x86_sse2_cvtss2sd,   x86_sse2_cvttpd2dq,   x86_sse2_cvttps2dq,   x86_sse2_cvttsd2si,   x86_sse2_cvttsd2si64,   x86_sse2_div_sd,   x86_sse2_lfence,   x86_sse2_maskmov_dqu,   x86_sse2_max_pd,   x86_sse2_max_sd,   x86_sse2_mfence,   x86_sse2_min_pd,   x86_sse2_min_sd,   x86_sse2_movmsk_pd,   x86_sse2_mul_sd,   x86_sse2_packssdw_128,   x86_sse2_packsswb_128,   x86_sse2_packuswb_128,   x86_sse2_padds_b,   x86_sse2_padds_w,   x86_sse2_paddus_b,   x86_sse2_paddus_w,   x86_sse2_pavg_b,   x86_sse2_pavg_w,   x86_sse2_pmadd_wd,   x86_sse2_pmaxs_w,   x86_sse2_pmaxu_b,   x86_sse2_pmins_w,   x86_sse2_pminu_b,   x86_sse2_pmovmskb_128,   x86_sse2_pmulh_w,   x86_sse2_pmulhu_w,   x86_sse2_pmulu_dq,   x86_sse2_psad_bw,   x86_sse2_psll_d,   x86_sse2_psll_dq,   x86_sse2_psll_dq_bs,   x86_sse2_psll_q,   x86_sse2_psll_w,   x86_sse2_pslli_d,   x86_sse2_pslli_q,   x86_sse2_pslli_w,   x86_sse2_psra_d,   x86_sse2_psra_w,   x86_sse2_psrai_d,   x86_sse2_psrai_w,   x86_sse2_psrl_d,   x86_sse2_psrl_dq,   x86_sse2_psrl_dq_bs,   x86_sse2_psrl_q,   x86_sse2_psrl_w,   x86_sse2_psrli_d,   x86_sse2_psrli_q,   x86_sse2_psrli_w,   x86_sse2_psubs_b,   x86_sse2_psubs_w,   x86_sse2_psubus_b,   x86_sse2_psubus_w,   x86_sse2_sqrt_pd,   x86_sse2_sqrt_sd,   x86_sse2_storel_dq,   x86_sse2_storeu_dq,   x86_sse2_storeu_pd,   x86_sse2_sub_sd,   x86_sse2_ucomieq_sd,   x86_sse2_ucomige_sd,   x86_sse2_ucomigt_sd,   x86_sse2_ucomile_sd,   x86_sse2_ucomilt_sd,   x86_sse2_ucomineq_sd,   x86_sse3_addsub_pd,   x86_sse3_addsub_ps,   x86_sse3_hadd_pd,   x86_sse3_hadd_ps,   x86_sse3_hsub_pd,   x86_sse3_hsub_ps,   x86_sse3_ldu_dq,   x86_sse3_monitor,   x86_sse3_mwait,   x86_sse41_blendpd,   x86_sse41_blendps,   x86_sse41_blendvpd,   x86_sse41_blendvps,   x86_sse41_dppd,   x86_sse41_dpps,   x86_sse41_extractps,   x86_sse41_insertps,   x86_sse41_movntdqa,   x86_sse41_mpsadbw,   x86_sse41_packusdw,   x86_sse41_pblendvb,   x86_sse41_pblendw,   x86_sse41_pextrb,   x86_sse41_pextrd,   x86_sse41_pextrq,   x86_sse41_phminposuw,   x86_sse41_pmaxsb,   x86_sse41_pmaxsd,   x86_sse41_pmaxud,   x86_sse41_pmaxuw,   x86_sse41_pminsb,   x86_sse41_pminsd,   x86_sse41_pminud,   x86_sse41_pminuw,   x86_sse41_pmovsxbd,   x86_sse41_pmovsxbq,   x86_sse41_pmovsxbw,   x86_sse41_pmovsxdq,   x86_sse41_pmovsxwd,   x86_sse41_pmovsxwq,   x86_sse41_pmovzxbd,   x86_sse41_pmovzxbq,   x86_sse41_pmovzxbw,   x86_sse41_pmovzxdq,   x86_sse41_pmovzxwd,   x86_sse41_pmovzxwq,   x86_sse41_pmuldq,   x86_sse41_ptestc,   x86_sse41_ptestnzc,   x86_sse41_ptestz,   x86_sse41_round_pd,   x86_sse41_round_ps,   x86_sse41_round_sd,   x86_sse41_round_ss,   x86_sse42_crc32_32_16,   x86_sse42_crc32_32_32,   x86_sse42_crc32_32_8,   x86_sse42_crc32_64_64,   x86_sse42_crc32_64_8,   x86_sse42_pcmpestri128,   x86_sse42_pcmpestria128,   x86_sse42_pcmpestric128,   x86_sse42_pcmpestrio128,   x86_sse42_pcmpestris128,   x86_sse42_pcmpestriz128,   x86_sse42_pcmpestrm128,   x86_sse42_pcmpistri128,   x86_sse42_pcmpistria128,   x86_sse42_pcmpistric128,   x86_sse42_pcmpistrio128,   x86_sse42_pcmpistris128,   x86_sse42_pcmpistriz128,   x86_sse42_pcmpistrm128,   x86_sse4a_extrq,   x86_sse4a_extrqi,   x86_sse4a_insertq,   x86_sse4a_insertqi,   x86_sse4a_movnt_sd,   x86_sse4a_movnt_ss,   x86_sse_add_ss,   x86_sse_cmp_ps,   x86_sse_cmp_ss,   x86_sse_comieq_ss,   x86_sse_comige_ss,   x86_sse_comigt_ss,   x86_sse_comile_ss,   x86_sse_comilt_ss,   x86_sse_comineq_ss,   x86_sse_cvtpd2pi,   x86_sse_cvtpi2pd,   x86_sse_cvtpi2ps,   x86_sse_cvtps2pi,   x86_sse_cvtsi2ss,   x86_sse_cvtsi642ss,   x86_sse_cvtss2si,   x86_sse_cvtss2si64,   x86_sse_cvttpd2pi,   x86_sse_cvttps2pi,   x86_sse_cvttss2si,   x86_sse_cvttss2si64,   x86_sse_div_ss,   x86_sse_ldmxcsr,   x86_sse_max_ps,   x86_sse_max_ss,   x86_sse_min_ps,   x86_sse_min_ss,   x86_sse_movmsk_ps,   x86_sse_mul_ss,   x86_sse_pshuf_w,   x86_sse_rcp_ps,   x86_sse_rcp_ss,   x86_sse_rsqrt_ps,   x86_sse_rsqrt_ss,   x86_sse_sfence,   x86_sse_sqrt_ps,   x86_sse_sqrt_ss,   x86_sse_stmxcsr,   x86_sse_storeu_ps,   x86_sse_sub_ss,   x86_sse_ucomieq_ss,   x86_sse_ucomige_ss,   x86_sse_ucomigt_ss,   x86_sse_ucomile_ss,   x86_sse_ucomilt_ss,   x86_sse_ucomineq_ss,   x86_ssse3_pabs_b,   x86_ssse3_pabs_b_128,   x86_ssse3_pabs_d,   x86_ssse3_pabs_d_128,   x86_ssse3_pabs_w,   x86_ssse3_pabs_w_128,   x86_ssse3_phadd_d,   x86_ssse3_phadd_d_128,   x86_ssse3_phadd_sw,   x86_ssse3_phadd_sw_128,   x86_ssse3_phadd_w,   x86_ssse3_phadd_w_128,   x86_ssse3_phsub_d,   x86_ssse3_phsub_d_128,   x86_ssse3_phsub_sw,   x86_ssse3_phsub_sw_128,   x86_ssse3_phsub_w,   x86_ssse3_phsub_w_128,   x86_ssse3_pmadd_ub_sw,   x86_ssse3_pmadd_ub_sw_128,   x86_ssse3_pmul_hr_sw,   x86_ssse3_pmul_hr_sw_128,   x86_ssse3_pshuf_b,   x86_ssse3_pshuf_b_128,   x86_ssse3_psign_b,   x86_ssse3_psign_b_128,   x86_ssse3_psign_d,   x86_ssse3_psign_d_128,   x86_ssse3_psign_w,   x86_ssse3_psign_w_128,   x86_tbm_bextri_u32,   x86_tbm_bextri_u64,   x86_vcvtph2ps_128,   x86_vcvtph2ps_256,   x86_vcvtps2ph_128,   x86_vcvtps2ph_256,   x86_wrfsbase_32,   x86_wrfsbase_64,   x86_wrgsbase_32,   x86_wrgsbase_64,   x86_xabort,   x86_xbegin,   x86_xend,   x86_xop_vfrcz_pd,   x86_xop_vfrcz_pd_256,   x86_xop_vfrcz_ps,   x86_xop_vfrcz_ps_256,   x86_xop_vfrcz_sd,   x86_xop_vfrcz_ss,   x86_xop_vpcmov,   x86_xop_vpcmov_256,   x86_xop_vpcomb,   x86_xop_vpcomd,   x86_xop_vpcomq,   x86_xop_vpcomub,   x86_xop_vpcomud,   x86_xop_vpcomuq,   x86_xop_vpcomuw,   x86_xop_vpcomw,   x86_xop_vpermil2pd,   x86_xop_vpermil2pd_256,   x86_xop_vpermil2ps,   x86_xop_vpermil2ps_256,   x86_xop_vphaddbd,   x86_xop_vphaddbq,   x86_xop_vphaddbw,   x86_xop_vphadddq,   x86_xop_vphaddubd,   x86_xop_vphaddubq,   x86_xop_vphaddubw,   x86_xop_vphaddudq,   x86_xop_vphadduwd,   x86_xop_vphadduwq,   x86_xop_vphaddwd,   x86_xop_vphaddwq,   x86_xop_vphsubbw,   x86_xop_vphsubdq,   x86_xop_vphsubwd,   x86_xop_vpmacsdd,   x86_xop_vpmacsdqh,   x86_xop_vpmacsdql,   x86_xop_vpmacssdd,   x86_xop_vpmacssdqh,   x86_xop_vpmacssdql,   x86_xop_vpmacsswd,   x86_xop_vpmacssww,   x86_xop_vpmacswd,   x86_xop_vpmacsww,   x86_xop_vpmadcsswd,   x86_xop_vpmadcswd,   x86_xop_vpperm,   x86_xop_vprotb,   x86_xop_vprotbi,   x86_xop_vprotd,   x86_xop_vprotdi,   x86_xop_vprotq,   x86_xop_vprotqi,   x86_xop_vprotw,   x86_xop_vprotwi,   x86_xop_vpshab,   x86_xop_vpshad,   x86_xop_vpshaq,   x86_xop_vpshaw,   x86_xop_vpshlb,   x86_xop_vpshld,   x86_xop_vpshlq,   x86_xop_vpshlw,   x86_xtest,   xcore_bitrev,   xcore_checkevent,   xcore_chkct,   xcore_clre,   xcore_clrsr,   xcore_crc32,   xcore_crc8,   xcore_eeu,   xcore_endin,   xcore_freer,   xcore_geted,   xcore_getet,   xcore_getid,   xcore_getps,   xcore_getr,   xcore_getst,   xcore_getts,   xcore_in,   xcore_inct,   xcore_initcp,   xcore_initdp,   xcore_initlr,   xcore_initpc,   xcore_initsp,   xcore_inshr,   xcore_int,   xcore_mjoin,   xcore_msync,   xcore_out,   xcore_outct,   xcore_outshr,   xcore_outt,   xcore_peek,   xcore_setc,   xcore_setclk,   xcore_setd,   xcore_setev,   xcore_setps,   xcore_setpsc,   xcore_setpt,   xcore_setrdy,   xcore_setsr,   xcore_settw,   xcore_setv,   xcore_sext,   xcore_ssync,   xcore_syncr,   xcore_testct,   xcore_testwct,   xcore_waitevent,   xcore_zext,   num_intrinsics };
 struct IITDescriptor {   enum IITDescriptorKind {     Void,     MMX,     Metadata,     Half,     Float,     Double,     Integer,     Vector,     Pointer,     Struct,     Argument,     ExtendVecArgument,     TruncVecArgument   } Kind;   union {     unsigned Integer_Width;     unsigned Float_Width;     unsigned Vector_Width;     unsigned Pointer_AddressSpace;     unsigned Struct_NumElements;     unsigned Argument_Info;   };   enum ArgKind {     AK_AnyInteger,     AK_AnyFloat,     AK_AnyVector,     AK_AnyPointer   };   unsigned getArgumentNumber() const {     (void)((!!(Kind == Argument || Kind == ExtendVecArgument ||                Kind == TruncVecArgument)) ||            (_wassert(L"Kind == Argument || Kind == ExtendVecArgument || Kind "                      L"== TruncVecArgument",                      L"..\\include\\llvm/IR/Intrinsics.h", 102),             0));     return Argument_Info >> 2;   }   ArgKind getArgumentKind() const {     (void)((!!(Kind == Argument || Kind == ExtendVecArgument ||                Kind == TruncVecArgument)) ||            (_wassert(L"Kind == Argument || Kind == ExtendVecArgument || Kind "                      L"== TruncVecArgument",                      L"..\\include\\llvm/IR/Intrinsics.h", 107),             0));     return (ArgKind)(Argument_Info & 3);   }   static IITDescriptor get(IITDescriptorKind K, unsigned Field) {     IITDescriptor Result = {K, {Field}};     return Result;   } };
 void getIntrinsicInfoTableEntries(ID id, SmallVectorImpl<IITDescriptor> &T);
 }
    class TargetTransformInfo {
  protected:   TargetTransformInfo *PrevTTI;
   static char ID;
 };
    class StringMapEntryBase {
 };
    class StringMapImpl {
  protected:   StringMapEntryBase **TheTable;
   unsigned NumBuckets;
   unsigned NumItems;
   unsigned NumTombstones;
   void swap(StringMapImpl &Other) {     std::swap(TheTable, Other.TheTable);     std::swap(NumBuckets, Other.NumBuckets);     std::swap(NumItems, Other.NumItems);     std::swap(NumTombstones, Other.NumTombstones);   }
 };
    template <typename ValueTy> class StringMapEntry : public StringMapEntryBase {
   StringMapEntry(StringMapEntry &E) = delete;
   void Destroy() {     MallocAllocator A;     Destroy(A);   }
 };
    template <typename ValueTy, typename AllocatorTy = MallocAllocator> class StringMap : public StringMapImpl {
 };
    }
    namespace llvm {
    namespace cl {
 void ParseCommandLineOptions(int argc, const char *const *argv,                              const char *Overview = 0);
 void MarkOptionsChanged();
 enum NumOccurrencesFlag {   Optional = 0x00,   ZeroOrMore = 0x01,   Required = 0x02,   OneOrMore = 0x03,   ConsumeAfter = 0x04 };
 enum ValueExpected {   ValueOptional = 0x01,   ValueRequired = 0x02,   ValueDisallowed = 0x03 };
 enum OptionHidden {   NotHidden = 0x00,   Hidden = 0x01,   ReallyHidden = 0x02 };
 enum FormattingFlags {   NormalFormatting = 0x00,   Positional = 0x01,   Prefix = 0x02,   Grouping = 0x03 };
 class OptionCategory {  private:   const char *const Name;   const char *const Description;   void registerCategory();  public:   OptionCategory(const char *const Name, const char *const Description = 0)       : Name(Name), Description(Description) {     registerCategory();   }   const char *getName() { return Name; }   const char *getDescription() { return Description; } };
 extern OptionCategory GeneralCategory;
 class Option {   friend class alias;   virtual bool handleOccurrence(unsigned pos, StringRef ArgName,                                 StringRef Arg) = 0;   virtual enum ValueExpected getValueExpectedFlagDefault() const {     return ValueOptional;   }   virtual void anchor();   int NumOccurrences;   unsigned Occurrences : 3;   unsigned Value : 2;   unsigned HiddenFlag : 2;   unsigned Formatting : 2;   unsigned Misc : 3;   unsigned Position;   unsigned AdditionalVals;   Option *NextRegistered;  public:   const char *ArgStr;   const char *HelpStr;   const char *ValueStr;   OptionCategory *Category;   inline enum NumOccurrencesFlag getNumOccurrencesFlag() const {     return (enum NumOccurrencesFlag)Occurrences;   }   inline enum ValueExpected getValueExpectedFlag() const {     return Value ? ((enum ValueExpected)Value) : getValueExpectedFlagDefault();   }   inline enum OptionHidden getOptionHiddenFlag() const {     return (enum OptionHidden)HiddenFlag;   }   inline enum FormattingFlags getFormattingFlag() const {     return (enum FormattingFlags)Formatting;   }   inline unsigned getMiscFlags() const { return Misc; }   inline unsigned getPosition() const { return Position; }   inline unsigned getNumAdditionalVals() const { return AdditionalVals; }   bool hasArgStr() const { return ArgStr[0] != 0; }   void setArgStr(const char *S) { ArgStr = S; }   void setDescription(const char *S) { HelpStr = S; }   void setValueStr(const char *S) { ValueStr = S; }   void setNumOccurrencesFlag(enum NumOccurrencesFlag Val) { Occurrences = Val; }   void setValueExpectedFlag(enum ValueExpected Val) { Value = Val; }   void setHiddenFlag(enum OptionHidden Val) { HiddenFlag = Val; }   void setFormattingFlag(enum FormattingFlags V) { Formatting = V; }   void setMiscFlag(enum MiscFlags M) { Misc |= M; }   void setPosition(unsigned pos) { Position = pos; }   void setCategory(OptionCategory &C) { Category = &C; }  protected:   explicit Option(enum NumOccurrencesFlag OccurrencesFlag,                   enum OptionHidden Hidden)       : NumOccurrences(0),         Occurrences(OccurrencesFlag),         Value(0),         HiddenFlag(Hidden),         Formatting(NormalFormatting),         Misc(0),         Position(0),         AdditionalVals(0),         NextRegistered(0),         ArgStr(""),         HelpStr(""),         ValueStr(""),         Category(&GeneralCategory) {}   inline void setNumAdditionalVals(unsigned n) { AdditionalVals = n; }  public:   void addArgument();   Option *getNextRegisteredOption() const { return NextRegistered; }   virtual size_t getOptionWidth() const = 0;   virtual void printOptionInfo(size_t GlobalWidth) const = 0;   virtual void printOptionValue(size_t GlobalWidth, bool Force) const = 0;   virtual void getExtraOptionNames(SmallVectorImpl<const char *> &) {}   bool addOccurrence(unsigned pos, StringRef ArgName, StringRef Value,                      bool MultiArg = false);   bool error(const Twine &Message, StringRef ArgName = StringRef());  public:   inline int getNumOccurrences() const { return NumOccurrences; }   virtual ~Option() {} };
 struct desc {   const char *Desc;   desc(const char *Str) : Desc(Str) {}   void apply(Option &O) const { O.setDescription(Desc); } };
 template <class Ty> struct initializer {   const Ty &Init;   initializer(const Ty &Val) : Init(Val) {}   template <class Opt>   void apply(Opt &O) const {     O.setInitialValue(Init);   } };
 template <class Ty> initializer<Ty> init(const Ty &Val) {   return initializer<Ty>(Val); }
 struct GenericOptionValue {   virtual ~GenericOptionValue() {}   virtual bool compare(const GenericOptionValue &V) const = 0; };
 template <class DataType> struct OptionValue;
 template <class DataType, bool isClass> struct OptionValueBase : public GenericOptionValue {   typedef OptionValue<DataType> WrapperType;   bool hasValue() const { return false; }   const DataType &getValue() const {     ::llvm::llvm_unreachable_internal(         "no default value", "..\\include\\llvm/Support/CommandLine.h", 366);   }   template <class DT>   void setValue(const DT &) {}   bool compare(const DataType &) const { return false; }   virtual bool compare(const GenericOptionValue &) const { return false; } };
 template <class DataType> class OptionValueCopy : public GenericOptionValue {   DataType Value;   bool Valid;  public:   OptionValueCopy() : Valid(false) {}   bool hasValue() const { return Valid; }   const DataType &getValue() const {     (void)((!!(Valid && "invalid option value")) ||            (_wassert(L"Valid && \"invalid option value\"",                      L"..\\include\\llvm/Support/CommandLine.h", 388),             0));     return Value;   }   void setValue(const DataType &V) {     Valid = true;     Value = V;   }   bool compare(const DataType &V) const { return Valid && (Value != V); }   virtual bool compare(const GenericOptionValue &V) const {     const OptionValueCopy<DataType> &VC =         static_cast<const OptionValueCopy<DataType> &>(V);     if (!VC.hasValue()) return false;     return compare(VC.getValue());   } };
 template <class DataType> struct OptionValueBase<DataType, false> : OptionValueCopy<DataType> {   typedef DataType WrapperType; };
 template <class DataType> struct OptionValue : OptionValueBase<DataType, is_class<DataType>::value> {   OptionValue() {}   OptionValue(const DataType &V) { this->setValue(V); }   template <class DT>   OptionValue<DataType> &operator=(const DT &V) {     this->setValue(V);     return *this;   } };
 class generic_parser_base {  protected:   class GenericOptionInfo {    public:     GenericOptionInfo(const char *name, const char *helpStr)         : Name(name), HelpStr(helpStr) {}     const char *Name;     const char *HelpStr;   };  public:   virtual ~generic_parser_base() {}   virtual unsigned getNumOptions() const = 0;   virtual const char *getOption(unsigned N) const = 0;   virtual const char *getDescription(unsigned N) const = 0;   virtual size_t getOptionWidth(const Option &O) const;   virtual const GenericOptionValue &getOptionValue(unsigned N) const = 0;   virtual void printOptionInfo(const Option &O, size_t GlobalWidth) const;   void printGenericOptionDiff(const Option &O, const GenericOptionValue &V,                               const GenericOptionValue &Default,                               size_t GlobalWidth) const;   template <class AnyOptionValue>   void printOptionDiff(const Option &O, const AnyOptionValue &V,                        const AnyOptionValue &Default,                        size_t GlobalWidth) const {     printGenericOptionDiff(O, V, Default, GlobalWidth);   }   void initialize(Option &O) { hasArgStr = O.hasArgStr(); }   void getExtraOptionNames(SmallVectorImpl<const char *> &OptionNames) {     if (!hasArgStr)       for (unsigned i = 0, e = getNumOptions(); i != e; ++i)         OptionNames.push_back(getOption(i));   }   enum ValueExpected getValueExpectedFlagDefault() const {     if (hasArgStr)       return ValueRequired;     else       return ValueDisallowed;   }   unsigned findOption(const char *Name);  protected:   bool hasArgStr; };
 template <class DataType> class parser : public generic_parser_base {  protected:   class OptionInfo : public GenericOptionInfo {    public:     OptionInfo(const char *name, DataType v, const char *helpStr)         : GenericOptionInfo(name, helpStr), V(v) {}     OptionValue<DataType> V;   };   SmallVector<OptionInfo, 8> Values;  public:   typedef DataType parser_data_type;   unsigned getNumOptions() const { return unsigned(Values.size()); }   const char *getOption(unsigned N) const { return Values[N].Name; }   const char *getDescription(unsigned N) const { return Values[N].HelpStr; }   virtual const GenericOptionValue &getOptionValue(unsigned N) const {     return Values[N].V;   }   bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V) {     StringRef ArgVal;     if (hasArgStr)       ArgVal = Arg;     else       ArgVal = ArgName;     for (size_t i = 0, e = Values.size(); i != e; ++i)       if (Values[i].Name == ArgVal) {         V = Values[i].V.getValue();         return false;       }     return O.error("Cannot find option named '" + ArgVal + "'!");   }   template <class DT>   void addLiteralOption(const char *Name, const DT &V, const char *HelpStr) {     (void)((!!(findOption(Name) == Values.size() &&                "Option already exists!")) ||            (_wassert(L"findOption(Name) == Values.size() && \"Option already "                      L"exists!\"",                      L"..\\include\\llvm/Support/CommandLine.h", 672),             0));     OptionInfo X(Name, static_cast<DataType>(V), HelpStr);     Values.push_back(X);     MarkOptionsChanged();   }   void removeLiteralOption(const char *Name) {     unsigned N = findOption(Name);     (void)((!!(N != Values.size() && "Option not found!")) ||            (_wassert(L"N != Values.size() && \"Option not found!\"",                      L"..\\include\\llvm/Support/CommandLine.h", 682),             0));     Values.erase(Values.begin() + N);   } };
 class basic_parser_impl {  public:   virtual ~basic_parser_impl() {}   enum ValueExpected getValueExpectedFlagDefault() const {     return ValueRequired;   }   void getExtraOptionNames(SmallVectorImpl<const char *> &) {}   void initialize(Option &) {}   size_t getOptionWidth(const Option &O) const;   void printOptionInfo(const Option &O, size_t GlobalWidth) const;   void printOptionNoValue(const Option &O, size_t GlobalWidth) const;   virtual const char *getValueName() const { return "value"; }   virtual void anchor();  protected:   void printOptionName(const Option &O, size_t GlobalWidth) const; };
 template <class DataType> class basic_parser : public basic_parser_impl {  public:   typedef DataType parser_data_type;   typedef OptionValue<DataType> OptVal; };
 template <> class parser<bool> : public basic_parser<bool> {   const char *ArgStr;  public:   bool parse(Option &O, StringRef ArgName, StringRef Arg, bool &Val);   template <class Opt>   void initialize(Opt &O) {     return false;   }   virtual const char *getValueName() const { return "char"; }   void printOptionDiff(const Option &O, char V, OptVal Default,                        size_t GlobalWidth) const;   virtual void anchor(); };
 template <class ParserClass, class DT> void printOptionDiff(const Option &O, const generic_parser_base &P, const DT &V,                      const OptionValue<DT> &Default, size_t GlobalWidth) {   OptionValue<DT> OV = V;   P.printOptionDiff(O, OV, Default, GlobalWidth); }
 template <class ParserDT, class ValDT> struct OptionDiffPrinter {   void print(const Option &O, const parser<ParserDT> P, const ValDT &,              const OptionValue<ValDT> &, size_t GlobalWidth) {     P.printOptionNoValue(O, GlobalWidth);   } };
 template <class ParserClass, class ValDT> void printOptionDiff(     const Option &O,     const basic_parser<typename ParserClass::parser_data_type> &P,     const ValDT &V, const OptionValue<ValDT> &Default, size_t GlobalWidth) {   OptionDiffPrinter<typename ParserClass::parser_data_type, ValDT> printer;   printer.print(O, static_cast<const ParserClass &>(P), V, Default,                 GlobalWidth); }
 template <class Mod> struct applicator {   template <class Opt>   static void opt(const Mod &M, Opt &O) {     M.apply(O);   } };
 template <unsigned n> struct applicator<char[n]> {   template <class Opt>   static void opt(const char *Str, Opt &O) {     O.setArgStr(Str);   } };
 template <> struct applicator<ValueExpected> {   static void opt(ValueExpected VE, Option &O) { O.setValueExpectedFlag(VE); } };
 template <> struct applicator<OptionHidden> {   static void opt(OptionHidden OH, Option &O) { O.setHiddenFlag(OH); } };
 template <> struct applicator<MiscFlags> {   static void opt(MiscFlags MF, Option &O) { O.setMiscFlag(MF); } };
 template <class Mod, class Opt> void apply(const Mod &M, Opt *O) {   applicator<Mod>::opt(M, *O); }
 template <class DataType, bool ExternalStorage, bool isClass> class opt_storage {   DataType *Location;   OptionValue<DataType> Default;   void check() const {     (void)((!!(Location != 0 &&                "cl::location(...) not specified for a command "                "line option with external storage, "                "or cl::init specified before cl::location()!!")) ||            (_wassert(L"Location != 0 && \"cl::location(...) not specified for "                      L"a command \" \"line option with external storage, \" "                      L"\"or cl::init specified before cl::location()!!\"",                      L"..\\include\\llvm/Support/CommandLine.h", 1058),             0));   }  public:   opt_storage() : Location(0) {}   bool setLocation(Option &O, DataType &L) {     if (Location) return O.error("cl::location(x) specified more than once!");     return Default;   } };
 template <class DataType> class opt_storage<DataType, false, true> : public DataType {  public:   OptionValue<DataType> Default;   template <class T>   void setValue(const T &V, bool initial = false) {     DataType::operator=(V);     if (initial) Default = V;   }   DataType &getValue() { return *this; }   const DataType &getValue() const { return *this; }   const OptionValue<DataType> &getDefault() const { return Default; } };
 template <class DataType> class opt_storage<DataType, false, false> {  public:   DataType Value;   OptionValue<DataType> Default;   opt_storage() : Value(DataType()), Default(DataType()) {}   template <class T>   void setValue(const T &V, bool initial = false) {     Value = V;     if (initial) Default = V;   }   DataType &getValue() { return Value; }   DataType getValue() const { return Value; }   const OptionValue<DataType> &getDefault() const { return Default; }   operator DataType() const { return getValue(); }   DataType operator->() const { return Value; } };
 template <class DataType, bool ExternalStorage = false,           class ParserClass = parser<DataType> > class opt     : public Option,       public opt_storage<DataType, ExternalStorage, is_class<DataType>::value> {   ParserClass Parser;   virtual bool handleOccurrence(unsigned pos, StringRef ArgName,                                 StringRef Arg) {     typename ParserClass::parser_data_type Val =         typename ParserClass::parser_data_type();     if (Parser.parse(*this, ArgName, Arg, Val)) return true;     this->setValue(Val);     this->setPosition(pos);     return false;   }   virtual enum ValueExpected getValueExpectedFlagDefault() const {     return Parser.getValueExpectedFlagDefault();   }   virtual void getExtraOptionNames(SmallVectorImpl<const char *> &OptionNames) {     return Parser.getExtraOptionNames(OptionNames);   }   virtual size_t getOptionWidth() const { return Parser.getOptionWidth(*this); }   virtual void printOptionInfo(size_t GlobalWidth) const {     Parser.printOptionInfo(*this, GlobalWidth);   }   virtual void printOptionValue(size_t GlobalWidth, bool Force) const {     if (Force || this->getDefault().compare(this->getValue())) {       cl::printOptionDiff<ParserClass>(*this, Parser, this->getValue(),                                        this->getDefault(), GlobalWidth);     }   }   void done() {     addArgument();     Parser.initialize(*this);   }  public:   void setInitialValue(const DataType &V) { this->setValue(V, true); }   ParserClass &getParser() { return Parser; }   template <class T>   DataType &operator=(const T &Val) {     this->setValue(Val);     return this->getValue();   }   template <class M0t>   explicit opt(const M0t &M0)       : Option(Optional, NotHidden) {     apply(M0, this);     done();   }   template <class M0t, class M1t>   opt(const M0t &M0, const M1t &M1)       : Option(Optional, NotHidden) {     apply(M0, this);     apply(M1, this);     done();   }   template <class M0t, class M1t, class M2t>   opt(const M0t &M0, const M1t &M1, const M2t &M2)       : Option(Optional, NotHidden) {     apply(M0, this);     apply(M1, this);     apply(M2, this);     done();   }   template <class M0t, class M1t, class M2t, class M3t>   opt(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3)       : Option(Optional, NotHidden) {     apply(M0, this);     apply(M1, this);     apply(M2, this);     apply(M3, this);     done();   }   template <class M0t, class M1t, class M2t, class M3t, class M4t>   opt(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3, const M4t &M4)       : Option(Optional, NotHidden) {     apply(M4, this);     apply(M5, this);     apply(M6, this);     done();   }   template <class M0t, class M1t, class M2t, class M3t, class M4t, class M5t,             class M6t, class M7t>   opt(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3, const M4t &M4,       const M5t &M5, const M6t &M6, const M7t &M7)       : Option(Optional, NotHidden) {     apply(M0, this);     apply(M1, this);     apply(M2, this);     apply(M3, this);     apply(M4, this);     apply(M5, this);     apply(M6, this);     apply(M7, this);     done();   } };
 ;
 }
    }
    namespace llvm {
    class raw_ostream;
    extern bool DebugFlag;
    bool isCurrentDebugType(const char *Type);
    extern bool EnableDebugBuffering;
    raw_ostream &dbgs();
    BasicBlock *SplitCriticalEdge(TerminatorInst *TI, unsigned SuccNum, Pass *P = 0,                               bool MergeIdenticalEdges = false,                               bool DontDeleteUselessPHIs = false,                               bool SplitLandingPads = false);
    inline BasicBlock *SplitCriticalEdge(BasicBlock *BB, succ_iterator SI,                                      Pass *P = 0) {
   return SplitCriticalEdge(BB->getTerminator(), SI.getSuccessorIndex(), P);
 }
    inline bool SplitCriticalEdge(BasicBlock *Succ, pred_iterator PI, Pass *P = 0) {
   bool MadeChange = false;
   TerminatorInst *TI = (*PI)->getTerminator();
   for (unsigned i = 0, e = TI->getNumSuccessors();
 i != e;
 ++i)     if (TI->getSuccessor(i) == Succ)       MadeChange |= !!SplitCriticalEdge(TI, i, P);
   return MadeChange;
 }
    inline BasicBlock *SplitCriticalEdge(BasicBlock *Src, BasicBlock *Dst,                                      Pass *P = 0,                                      bool MergeIdenticalEdges = false,                                      bool DontDeleteUselessPHIs = false) {
 }
    BasicBlock *SplitEdge(BasicBlock *From, BasicBlock *To, Pass *P);
    void llvm_execute_on_thread(void (*UserFn)(void *), void *UserData,                             unsigned RequestedStackSize = 0);
    }
    namespace llvm {
    namespace sys {
 }
    template <typename KeyT, typename ValueT, typename Config> class ValueMapCallbackVH;
    template <typename KeyT> struct ValueMapConfig {
   enum {     FollowRAUW = true   };
   struct ExtraData {};
 };
    template <typename KeyT, typename ValueT,           typename Config = ValueMapConfig<KeyT> > class ValueMap {
   friend class ValueMapCallbackVH<KeyT, ValueT, Config>;
   typedef ValueMapCallbackVH<KeyT, ValueT, Config> ValueMapCVH;
   typedef DenseMap<ValueMapCVH, ValueT, DenseMapInfo<ValueMapCVH> > MapT;
   typedef typename Config::ExtraData ExtraData;
   MapT Map;
   ExtraData Data;
  public:   typedef KeyT key_type;
   ValueT &operator[](const KeyT &Key) { return Map[Wrap(Key)]; }
  private:   ValueMapCVH Wrap(KeyT key) const {     return ValueMapCVH(key, const_cast<ValueMap *>(this));   }
 };
    template <typename KeyT, typename ValueT, typename Config> class ValueMapCallbackVH : public CallbackVH {
   friend class ValueMap<KeyT, ValueT, Config>;
   friend struct DenseMapInfo<ValueMapCallbackVH>;
   typedef ValueMap<KeyT, ValueT, Config> ValueMapT;
   ValueMapT *Map;
   ValueMapCallbackVH(KeyT Key, ValueMapT *Map)       : CallbackVH(const_cast<Value *>(static_cast<const Value *>(Key))),         Map(Map) {}
 };
    template <typename KeyT, typename ValueT, typename Config> struct DenseMapInfo<ValueMapCallbackVH<KeyT, ValueT, Config> > {
   typedef ValueMapCallbackVH<KeyT, ValueT, Config> VH;
   typedef DenseMapInfo<KeyT> PointerInfo;
   static inline VH getEmptyKey() { return VH(PointerInfo::getEmptyKey(), 0); }
   static inline VH getTombstoneKey() {     return VH(PointerInfo::getTombstoneKey(), 0);   }
   static unsigned getHashValue(const KeyT &Val) {     return PointerInfo::getHashValue(Val);   }
   static bool isEqual(const VH &LHS, const VH &RHS) { return LHS == RHS; }
 };
    class Instruction;
    typedef ValueMap<const Value *, WeakVH> ValueToValueMapTy;
    class ValueMapTypeRemapper {
 };
    class ValueMaterializer {
 };
    enum RemapFlags {
   RF_None = 0,   RF_NoModuleLevelChanges = 1,   RF_IgnoreMissingEntries = 2 };
    static inline RemapFlags operator|(RemapFlags LHS, RemapFlags RHS) {
   return RemapFlags(unsigned(LHS) | unsigned(RHS));
 }
    Value *MapValue(const Value *V, ValueToValueMapTy &VM,                 RemapFlags Flags = RF_None,                 ValueMapTypeRemapper *TypeMapper = 0,                 ValueMaterializer *Materializer = 0);
    void RemapInstruction(Instruction *I, ValueToValueMapTy &VM,                       RemapFlags Flags = RF_None,                       ValueMapTypeRemapper *TypeMapper = 0,                       ValueMaterializer *Materializer = 0);
    inline MDNode *MapValue(const MDNode *V, ValueToValueMapTy &VM,                         RemapFlags Flags = RF_None,                         ValueMapTypeRemapper *TypeMapper = 0,                         ValueMaterializer *Materializer = 0) {
   return cast<MDNode>(       MapValue((const Value *)V, VM, Flags, TypeMapper, Materializer));
 }
    struct ClonedCodeInfo {
   bool ContainsCalls;
   bool ContainsDynamicAllocas;
   ClonedCodeInfo() : ContainsCalls(false), ContainsDynamicAllocas(false) {}
 };
    BasicBlock *CloneBasicBlock(const BasicBlock *BB, ValueToValueMapTy &VMap,                             const Twine &NameSuffix = "", Function *F = 0,                             ClonedCodeInfo *CodeInfo = 0);
    }
    using namespace llvm;
    static llvm::Statistic NumBranches = {
        "loop-unswitch", "Number of branches unswitched", 0, 0};
    static llvm::Statistic NumSwitches = {
        "loop-unswitch", "Number of switches unswitched", 0, 0};
    static llvm::Statistic NumSelects = {
        "loop-unswitch", "Number of selects unswitched", 0, 0};
    static llvm::Statistic TotalInsts = {
        "loop-unswitch", "Total number of instructions analyzed", 0, 0};
    static cl::opt<unsigned> Threshold("loop-unswitch-threshold",                                    cl::desc("Max loop size to unswitch"),                                    cl::init(100), cl::Hidden);
    namespace {
    class LUAnalysisCache {
   typedef DenseMap<const SwitchInst *, SmallPtrSet<const Value *, 8> >       UnswitchedValsMap;
   typedef UnswitchedValsMap::iterator UnswitchedValsIt;
   struct LoopProperties {     unsigned CanBeUnswitchedCount;     unsigned SizeEstimation;     UnswitchedValsMap UnswitchedVals;   };
   UnswitchedValsMap *CurLoopInstructions;
   LoopProperties *CurrentLoopProperties;
   unsigned MaxSize;
  public:   LUAnalysisCache()       : CurLoopInstructions(0), CurrentLoopProperties(0), MaxSize(Threshold) {}
   bool countLoop(const Loop *L, const TargetTransformInfo &TTI);
   void setUnswitched(const SwitchInst *SI, const Value *V);
   bool isUnswitched(const SwitchInst *SI, const Value *V);
 };
    class LoopUnswitch : public LoopPass {
   LUAnalysisCache BranchesInfo;
   bool OptimizeForSize;
   bool redoLoop;
   Loop *currentLoop;
   DominatorTree *DT;
   BasicBlock *loopHeader;
   BasicBlock *loopPreheader;
   std::vector<BasicBlock *> LoopBlocks;
   std::vector<BasicBlock *> NewBlocks;
  public:   static char ID;
   explicit LoopUnswitch(bool Os = false)       : LoopPass(ID),         OptimizeForSize(Os),         redoLoop(false),         currentLoop(0),         DT(0),         loopHeader(0),         loopPreheader(0) {     initializeLoopUnswitchPass(*PassRegistry::getPassRegistry());   }
   bool runOnLoop(Loop *L, LPPassManager &LPM);
   bool processCurrentLoop();
   void SplitExitEdges(Loop *L, const SmallVectorImpl<BasicBlock *> &ExitBlocks);
   bool UnswitchIfProfitable(Value *LoopCond, Constant *Val);
   void UnswitchTrivialCondition(Loop *L, Value *Cond, Constant *Val,                                 BasicBlock *ExitBlock);
   void UnswitchNontrivialCondition(Value *LIC, Constant *OnVal, Loop *L);
   void RewriteLoopBodyWithConditionConstant(Loop *L, Value *LIC, Constant *Val,                                             bool isEqual);
   bool IsTrivialUnswitchCondition(Value *Cond, Constant **Val = 0,                                   BasicBlock **LoopExit = 0);
 };
    }
    Pass *llvm::createLoopUnswitchPass(bool Os) {
    return new LoopUnswitch(Os);
    }
    static Value *FindLIVLoopCondition(Value *Cond, Loop *L, bool &Changed) {
      ++TotalInsts;
      if (BinaryOperator *BO = dyn_cast<BinaryOperator>(Cond))     if (BO->getOpcode() == Instruction::And ||         BO->getOpcode() == Instruction::Or) {
     }
      return 0;
    }
    bool LoopUnswitch::runOnLoop(Loop *L, LPPassManager &LPM_Ref) {
      Function *F = currentLoop->getHeader()->getParent();
      bool Changed = false;
      do {
     Changed |= processCurrentLoop();
   }
    while (redoLoop);
    }
    bool LoopUnswitch::processCurrentLoop() {
      bool Changed = false;
      LLVMContext &Context = loopHeader->getContext();
      if (!BranchesInfo.countLoop(currentLoop, getAnalysis<TargetTransformInfo>()))     return false;
      for (Loop::block_iterator I = currentLoop->block_begin(),                             E = currentLoop->block_end();
           I != E;
    ++I) {
     TerminatorInst *TI = (*I)->getTerminator();
     if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {       if (BI->isConditional()) {         Value *LoopCond =             FindLIVLoopCondition(BI->getCondition(), currentLoop, Changed);         if (LoopCond &&             UnswitchIfProfitable(LoopCond, ConstantInt::getTrue(Context))) {           ++NumBranches;           return true;         }       }     }
 else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {       Value *LoopCond =           FindLIVLoopCondition(SI->getCondition(), currentLoop, Changed);       unsigned NumCases = SI->getNumCases();       if (LoopCond && NumCases) {         Constant *UnswitchVal = 0;         for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end();              i != e; ++i) {           Constant *UnswitchValCandidate = i.getCaseValue();           if (!BranchesInfo.isUnswitched(SI, UnswitchValCandidate)) {             UnswitchVal = UnswitchValCandidate;             break;           }         }         if (!UnswitchVal) continue;         if (UnswitchIfProfitable(LoopCond, UnswitchVal)) {           ++NumSwitches;           return true;         }       }     }
   }
      return Changed;
    }
    bool LoopUnswitch::UnswitchIfProfitable(Value *LoopCond, Constant *Val) {
      Function *F = loopHeader->getParent();
      Constant *CondVal = 0;
      BasicBlock *ExitBlock = 0;
      if (IsTrivialUnswitchCondition(LoopCond, &CondVal, &ExitBlock)) {
     UnswitchTrivialCondition(currentLoop, LoopCond, CondVal, ExitBlock);
   }
      if (OptimizeForSize ||       F->getAttributes().hasAttribute(AttributeSet::FunctionIndex,                                       Attribute::OptimizeForSize))     return false;
      UnswitchNontrivialCondition(LoopCond, Val, currentLoop);
      return true;
    }
    static Loop *CloneLoop(Loop *L, Loop *PL, ValueToValueMapTy &VM, LoopInfo *LI,                        LPPassManager *LPM) {
    }
    void LoopUnswitch::UnswitchNontrivialCondition(Value *LIC, Constant *Val,                                                Loop *L) {
      Function *F = loopHeader->getParent();
      do {
     if (::llvm::DebugFlag && ::llvm::isCurrentDebugType("loop-unswitch")) {       dbgs() << "loop-unswitch: Unswitching loop %" << loopHeader->getName()              << " [" << L->getBlocks().size() << " blocks] in Function "              << F->getName() << " when '" << *Val << "' == " << *LIC << "\n";     }
   }
    while (0);
      if (ScalarEvolution *SE = getAnalysisIfAvailable<ScalarEvolution>())     SE->forgetLoop(L);
      NewBlocks.clear();
      BasicBlock *NewPreheader = SplitEdge(loopPreheader, loopHeader, this);
      SmallVector<BasicBlock *, 8> ExitBlocks;
      L->getUniqueExitBlocks(ExitBlocks);
      NewBlocks.reserve(LoopBlocks.size());
      ValueToValueMapTy VMap;
      for (unsigned i = 0, e = LoopBlocks.size();
    i != e;
    ++i) {
   }
      F->getBasicBlockList().splice(NewPreheader, F->getBasicBlockList(),                                 NewBlocks[0], F->end());
      for (unsigned i = 0, e = ExitBlocks.size();
    i != e;
    ++i) {
     BasicBlock *NewExit = cast<BasicBlock>(VMap[ExitBlocks[i]]);
   }
      for (unsigned i = 0, e = NewBlocks.size();
    i != e;
    ++i)     for (BasicBlock::iterator I = NewBlocks[i]->begin(),                               E = NewBlocks[i]->end();
             I != E;
    ++I)       RemapInstruction(I, VMap,                        RF_NoModuleLevelChanges | RF_IgnoreMissingEntries);
    }


// this should reproduce the crash:
// /usr/local/google/home/rnk/creduce/build/creduce/../clang_delta/clang_delta --transformation=replace-function-def-with-decl --counter=1 /usr/local/google/home/rnk/creduce/build/clang_delta_crash_tmp_fileOEa1FV.ii