1/* { dg-do compile } */
2/* { dg-options "-Wno-sign-compare -Wno-return-type -Wno-overflow" } */
3/* { dg-additional-options "-mthumb" { target arm_thumb2_ok } } */
4
5struct A {
6  enum { __value };
7};
8template <class _T1> struct B { _T1 first; };
9template <typename _Iterator, bool> struct C {
10  typedef typename _Iterator::iterator_type iterator_type;
11  static iterator_type _S_base(_Iterator p1) { return p1.base(); }
12};
13template <typename _RandomAccessIterator>
14typename _RandomAccessIterator::difference_type
15__distance(_RandomAccessIterator p1, _RandomAccessIterator p2, int) {
16  return p2 - p1;
17}
18
19template <typename _InputIterator>
20typename _InputIterator::difference_type distance(_InputIterator p1,
21                                                  _InputIterator p2) {
22  return __distance(p1, p2, 0);
23}
24
25template <typename _Iterator, typename> class D {
26  _Iterator _M_current;
27
28public:
29  typedef _Iterator iterator_type;
30  typedef int difference_type;
31  _Iterator base() { return _M_current; }
32};
33
34template <typename _Iterator, typename _Container>
35typename D<_Iterator, _Container>::difference_type
36operator-(D<_Iterator, _Container> p1, D<_Iterator, _Container> p2) {
37  return p1.base() - p2.base();
38}
39
40struct F {
41  static unsigned short *__copy_m(unsigned short *p1, unsigned short *p2,
42                                  unsigned short *p3) {
43    int a = p2 - p1;
44    if (a)
45      __builtin_memmove(p3, p1, a);
46    return p3 + a;
47  }
48};
49class G {
50public:
51  void allocate(int p1) {
52    if (p1 > max_size())
53      operator new(sizeof(short));
54  }
55  unsigned max_size() { return -1 / sizeof(short); }
56};
57
58template <typename> class L : public G {};
59
60struct H {
61  static unsigned short *allocate(int p1) {
62    L<short> d;
63    d.allocate(p1);
64  }
65};
66struct I {
67  template <typename _InputIterator, typename _ForwardIterator>
68  static _ForwardIterator __uninit_copy(_InputIterator p1, _InputIterator p2,
69                                        _ForwardIterator p3) {
70    return copy(p1, p2, p3);
71  }
72};
73struct J {
74  typedef unsigned short *pointer;
75  struct K {
76    unsigned short *_M_start;
77    unsigned short *_M_finish;
78  };
79  J();
80  J(int p1, int) { _M_create_storage(p1); }
81  K _M_impl;
82  pointer _M_allocate(unsigned p1) { p1 ? H::allocate(p1) : pointer(); }
83  void _M_create_storage(int p1) { _M_allocate(p1); }
84};
85
86C<D<unsigned short *, int>, 1>::iterator_type
87__miter_base(D<unsigned short *, int> p1) {
88  return C<D<unsigned short *, int>, 1>::_S_base(p1);
89}
90
91template <bool, typename _II, typename _OI>
92_OI __copy_move_a(_II p1, _II p2, _OI p3) {
93  return F::__copy_m(p1, p2, p3);
94}
95
96template <bool _IsMove, typename _II, typename _OI>
97_OI __copy_move_a2(_II p1, _II p2, _OI p3) {
98  return __copy_move_a<_IsMove>(p1, p2, p3);
99}
100
101template <typename _II, typename _OI> _OI copy(_II p1, _II p2, _OI p3) {
102  C<D<unsigned short *, int>, 1>::iterator_type b, c = __miter_base(p1);
103  b = __miter_base(p2);
104  return __copy_move_a2<A::__value>(c, b, p3);
105}
106
107template <typename _InputIterator, typename _ForwardIterator>
108_ForwardIterator uninitialized_copy(_InputIterator p1, _InputIterator p2,
109                                    _ForwardIterator p3) {
110  return I::__uninit_copy(p1, p2, p3);
111}
112
113template <typename _InputIterator, typename _ForwardIterator, typename _Tp>
114_ForwardIterator __uninitialized_copy_a(_InputIterator p1, _InputIterator p2,
115                                        _ForwardIterator p3, L<_Tp>) {
116  return uninitialized_copy(p1, p2, p3);
117}
118
119class M : J {
120  J _Base;
121
122public:
123  M();
124  M(int p1, int p2 = int()) : _Base(p1, p2) {}
125  M(D<unsigned short *, int> p1, D<unsigned short *, int> p2) {
126    _M_initialize_dispatch(p1, p2, int());
127  }
128  D<pointer, int> begin();
129  D<pointer, int> end();
130  int size() { return _M_impl._M_finish - _M_impl._M_start; }
131  void _M_initialize_dispatch(D<unsigned short *, int> p1,
132                              D<unsigned short *, int> p2, int) {
133    L<short> e;
134    int f = distance(p1, p2);
135    _M_impl._M_start = _M_allocate(f);
136    _M_impl._M_finish = __uninitialized_copy_a(p1, p2, _M_impl._M_start, e);
137  }
138};
139
140B<M> g, h;
141void twoMeans() {
142  M i(g.first.begin(), h.first.end());
143  M(i.size());
144}
145