1// { dg-do compile { target c++11 } }
2// { dg-options "-fcompare-debug" }
3
4typedef __SIZE_TYPE__ size_t;
5namespace
6{
7  template < typename _Tp, _Tp __v > struct integral_constant
8  {
9    static const _Tp value = __v;
10  };
11  typedef integral_constant < bool, false > false_type;
12  template < typename > struct remove_cv;
13  template < typename > struct __is_void_helper:false_type
14  {
15  };
16  template
17    <
18    typename
19    _Tp
20    >
21    struct
22    is_void:integral_constant
23    < bool, (__is_void_helper < typename remove_cv < _Tp >::type >::value) >
24  {
25  };
26  template < typename > struct is_function:false_type
27  {
28  };
29  template < typename _Tp > struct remove_const
30  {
31    typedef _Tp type;
32  };
33  template < typename _Tp > struct remove_volatile
34  {
35    typedef _Tp type;
36  };
37  template < typename _Tp > struct remove_cv
38  {
39    typedef
40      typename
41      remove_const < typename remove_volatile < _Tp >::type >::type type;
42  };
43  template < typename > struct is_lvalue_reference:false_type
44  {
45  };
46  template < typename _Tp, bool = is_void < _Tp >::value > struct __add_rvalue_reference_helper
47  {
48    typedef _Tp type;
49  };
50  template
51    <
52    typename
53    _Tp > struct add_rvalue_reference:__add_rvalue_reference_helper < _Tp >
54  {
55  };
56  template
57    < typename _Tp > typename add_rvalue_reference < _Tp >::type declval ();
58  template
59    <
60    typename,
61    typename
62    _To, bool = (is_function < _To >::value) > struct __is_convertible_helper;
63  template
64    <
65    typename
66    _From, typename _To > struct __is_convertible_helper <_From, _To, false >
67  {
68    static const bool __value = sizeof ((declval < _From > ()));
69  };
70  template
71    <
72    typename
73    _From,
74    typename
75    _To
76    >
77    struct
78    is_convertible:integral_constant
79    < bool, __is_convertible_helper < _From, _To >::__value >
80  {
81  };
82  template < bool, typename _Tp = void >struct enable_if
83  {
84    typedef _Tp type;
85  };
86  template < typename _Tp > struct identity
87  {
88    typedef _Tp type;
89  };
90  template
91    <
92    typename
93    _Tp
94    >
95    typename
96    enable_if
97    <
98    is_lvalue_reference
99    < _Tp >::value, _Tp >::type forward (typename identity < _Tp >::type)
100  {
101    return 0;
102
103  }
104  template < class _T1, class > struct pair
105  {
106    _T1 first;
107    template < class _U1, class = typename enable_if < is_convertible < _U1, _T1 >::value >::type > pair (_U1 __x):
108    first
109      (forward < _U1 > (__x))
110    {
111    }
112  };
113}
114
115namespace __gnu_cxx
116{
117  template < typename > class new_allocator
118  {
119  };
120}
121
122namespace std
123{
124  template < typename _Tp > class allocator:__gnu_cxx::new_allocator < _Tp >
125  {
126  public:
127    template < typename > struct rebind
128    {
129      typedef allocator other;
130    };
131  };
132  template < typename, typename > struct unary_function;
133  template < typename, typename, typename > struct binary_function
134  {
135  };
136  template < typename _Tp > struct less:binary_function < _Tp, _Tp, bool >
137  {
138  };
139  template
140    <
141    typename
142    _Pair
143    > struct _Select1st:unary_function < _Pair, typename _Pair::first_type >
144  {
145  };
146  template < typename > struct _Rb_tree_node;
147  template
148    <
149    typename,
150    typename
151    _Val,
152    typename,
153    typename _Compare, typename _Alloc = allocator < _Val > >class _Rb_tree
154  {
155    typedef
156      typename
157      _Alloc::template
158      rebind < _Rb_tree_node < _Val > >::other _Node_allocator;
159  public:
160    typedef _Alloc allocator_type;
161    template < typename _Key_compare > struct _Rb_tree_impl
162    {
163      _Rb_tree_impl (_Key_compare, _Node_allocator);
164    };
165    _Rb_tree_impl < _Compare > _M_impl;
166  _Rb_tree (_Compare __comp, allocator_type __a):
167    _M_impl (__comp, __a)
168    {
169    }
170  };
171  template < class _E > class initializer_list
172  {
173    typedef size_t size_type;
174    typedef _E *iterator;
175    iterator _M_array;
176    size_type _M_len;
177  };
178  template
179    <
180    typename
181    _Key,
182    typename
183    _Tp,
184    typename
185    _Compare
186    =
187    less
188    <
189    _Key >, typename _Alloc = allocator < pair < _Key, _Tp > > >class multimap
190  {
191    typedef _Key key_type;
192    typedef pair < _Key, _Tp > value_type;
193    typedef _Compare key_compare;
194    typedef _Alloc allocator_type;
195    typedef
196      _Rb_tree
197      <
198      key_type,
199      value_type, _Select1st < value_type >, key_compare > _Rep_type;
200    _Rep_type _M_t;
201  public:
202  multimap (initializer_list < value_type >, _Compare __comp = _Compare (), allocator_type __a = allocator_type ()):
203    _M_t
204      (__comp, __a)
205    {
206    }
207  };
208}
209
210using namespace std;
211void
212test01 ()
213{
214  typedef multimap < int, double >Container;
215  Container (
216	      {
217	      {
218	      1}
219	      }
220  );
221}
222