1/* { dg-do compile } */
2/* { dg-options "-O2" } */
3
4namespace std
5{
6  template < class _T1, class _T2 > struct pair
7  {
8  };
9}
10extern "C"
11{
12  extern "C"
13  {
14    typedef int int32_t __attribute__ ((__mode__ (__SI__)));
15    struct _pthread_fastlock
16    {
17    }
18    pthread_mutexattr_t;
19  }
20}
21namespace std
22{
23  struct __numeric_limits_base
24  {
25  };
26    template < typename _Tp >
27    struct numeric_limits:public __numeric_limits_base
28  {
29    static const bool is_integer = true;
30  };
31};
32typedef unsigned int uint32_t;
33namespace std
34{
35  template < typename _Alloc > class allocator;
36  template < class _CharT > struct char_traits;
37    template < typename _CharT, typename _Traits =
38    char_traits < _CharT >, typename _Alloc =
39    allocator < _CharT > >class basic_string;
40  typedef basic_string < char >string;
41}
42namespace __gnu_cxx
43{
44  template < typename _Tp > class new_allocator
45  {
46  };
47}
48namespace std
49{
50  template < typename _Tp > class allocator:public __gnu_cxx::new_allocator <
51    _Tp >
52  {
53  };
54  template < typename _CharT, typename _Traits,
55    typename _Alloc > class basic_string
56  {
57  public:inline basic_string ();
58    basic_string (const _CharT * __s, const _Alloc & __a = _Alloc ());
59  };
60}
61namespace boost
62{
63  template < class T > class integer_traits:public std::numeric_limits < T >
64  {
65  };
66  namespace detail
67  {
68    template < class T, T min_val, T max_val > class integer_traits_base
69    {
70    };
71  }
72  template <> class integer_traits < int >:public std::numeric_limits < int >,
73    public detail::integer_traits_base < int, (-2147483647 - 1), 2147483647 >
74  {
75  };
76  namespace random
77  {
78    template < class IntType, IntType m > class const_mod
79    {
80    public:static IntType add (IntType x, IntType c)
81      {
82      }
83      static IntType mult (IntType a, IntType x)
84      {
85	return mult_schrage (a, x);
86      }
87      static IntType mult_add (IntType a, IntType x, IntType c)
88      {
89	return add (mult (a, x), c);
90      }
91      static IntType mult_schrage (IntType a, IntType value)
92      {
93	for (;;)
94	  {
95	    if (value > 0)
96	      break;
97	    value += m;
98	  }
99      }
100    };
101    template < class IntType, IntType a, IntType c, IntType m,
102      IntType val > class linear_congruential
103    {
104    public:typedef IntType result_type;
105      static const IntType modulus = m;
106    explicit linear_congruential (IntType x0 = 1):_modulus (modulus),
107	_x (_modulus ? (x0 % _modulus) :
108	    x0)
109      {
110      }
111      IntType operator    () ()
112      {
113	_x = const_mod < IntType, m >::mult_add (a, _x, c);
114      }
115    private:IntType _modulus;
116      IntType _x;
117    };
118  }
119  typedef random::linear_congruential < int32_t, 16807, 0, 2147483647,
120    1043618065 > minstd_rand0;
121  namespace random
122  {
123    namespace detail
124    {
125      template < class T > struct ptr_helper
126      {
127	typedef T value_type;
128	typedef T & reference_type;
129	typedef const T & rvalue_type;
130	static reference_type ref (T & r)
131	{
132	}
133      };
134        template < class T > struct ptr_helper <T & >
135      {
136	typedef T value_type;
137	typedef T & rvalue_type;
138      };
139    }
140  }
141  template < class UniformRandomNumberGenerator, class RealType =
142    double >class uniform_01
143  {
144  public:typedef UniformRandomNumberGenerator base_type;
145    typedef RealType result_type;
146    explicit uniform_01 (base_type rng):_rng (rng),
147      _factor (result_type (1) /
148	       (result_type ((_rng.max) () - (_rng.min) ()) +
149		result_type (std::numeric_limits <
150			     base_result >::is_integer ? 1 : 0)))
151    {
152    }
153    result_type operator    () ()
154    {
155      return result_type (_rng () - (_rng.min) ()) * _factor;
156    }
157  private:typedef typename base_type::result_type base_result;
158    base_type _rng;
159    result_type _factor;
160  };
161  namespace random
162  {
163    namespace detail
164    {
165      template < class UniformRandomNumberGenerator >
166	class pass_through_engine
167      {
168      private:typedef ptr_helper < UniformRandomNumberGenerator >
169	  helper_type;
170      public:typedef typename helper_type::value_type base_type;
171	typedef typename base_type::result_type result_type;
172	explicit pass_through_engine (UniformRandomNumberGenerator
173				      rng):_rng (static_cast <
174						 typename helper_type::
175						 rvalue_type > (rng))
176	{
177	}
178	result_type min () const
179	{
180	}
181	result_type max () const
182	{
183	}
184	base_type & base ()
185	{
186	}
187	result_type operator    () ()
188	{
189	  return base ()();
190	}
191      private:UniformRandomNumberGenerator _rng;
192      };
193    }
194    template < class RealType, int w, unsigned int p,
195      unsigned int q > class lagged_fibonacci_01
196    {
197    public:typedef RealType result_type;
198      static const unsigned int long_lag = p;
199        lagged_fibonacci_01 ()
200      {
201	seed ();
202      }
203    public:void seed (uint32_t value = 331u)
204      {
205	minstd_rand0 intgen (value);
206	seed (intgen);
207      }
208      template < class Generator > void seed (Generator & gen)
209      {
210	typedef detail::pass_through_engine < Generator & >ref_gen;
211	uniform_01 < ref_gen, RealType > gen01 =
212	  uniform_01 < ref_gen, RealType > (ref_gen (gen));
213	for (unsigned int j = 0; j < long_lag; ++j)
214	  x[j] = gen01 ();
215      }
216      RealType x[long_lag];
217    };
218  }
219  typedef random::lagged_fibonacci_01 < double, 48, 607,
220    273 > lagged_fibonacci607;
221  namespace random
222  {
223    namespace detail
224    {
225      template < bool have_int, bool want_int > struct engine_helper;
226        template <> struct engine_helper <true, true >
227      {
228	template < class Engine, class DistInputType > struct impl
229	{
230	  typedef pass_through_engine < Engine > type;
231	};
232      };
233    }
234  }
235  template < class Engine, class Distribution > class variate_generator
236  {
237  private:typedef random::detail::pass_through_engine < Engine >
238      decorated_engine;
239  public:typedef typename decorated_engine::base_type engine_value_type;
240    typedef Distribution distribution_type;
241  variate_generator (Engine e, Distribution d):_eng (decorated_engine (e)),
242      _dist (d)
243    {
244    }
245  private:enum
246    {
247      have_int =
248	std::numeric_limits <
249	typename decorated_engine::result_type >::is_integer, want_int =
250	std::numeric_limits < typename Distribution::input_type >::is_integer
251    };
252    typedef typename random::detail::engine_helper < have_int,
253      want_int >::template impl < decorated_engine,
254      typename Distribution::input_type >::type internal_engine_type;
255    internal_engine_type _eng;
256    distribution_type _dist;
257  };
258  template < class RealType = double >class uniform_real
259  {
260  public:typedef RealType input_type;
261  };
262}
263namespace alps
264{
265  class BufferedRandomNumberGeneratorBase
266  {
267  };
268    template < class RNG >
269    class BufferedRandomNumberGenerator:public
270    BufferedRandomNumberGeneratorBase
271  {
272  public: BufferedRandomNumberGenerator ():rng_ (), gen_ (rng_,
273		   boost::
274		   uniform_real <> ())
275    {
276    }
277  protected:  RNG rng_;
278    boost::variate_generator < RNG &, boost::uniform_real <> >gen_;
279  };
280}
281namespace boost
282{
283  namespace detail
284  {
285    class sp_counted_base
286    {
287    };
288    class shared_count
289    {
290    private:sp_counted_base * pi_;
291    public:shared_count ():pi_ (0)
292      {
293      }
294      template < class Y > explicit shared_count (Y * p):pi_ (0)
295      {
296      }
297    };
298  }
299  template < class T > class shared_ptr
300  {
301  public:typedef T element_type;
302  template < class Y > explicit shared_ptr (Y * p):px (p), pn (p)
303    {
304    }
305    T *px;
306    detail::shared_count pn;
307  };
308}
309namespace std
310{
311  template < typename _Key, typename _Tp, typename _Compare =
312    std::allocator < std::pair < const _Key, _Tp > > > class map
313  {
314  public:typedef _Key key_type;
315    typedef _Tp mapped_type;
316      mapped_type & operator[] (const key_type & __k)
317    {
318    }
319  };
320}
321namespace alps
322{
323  namespace detail
324  {
325    template < class BASE > class abstract_creator
326    {
327    public:typedef BASE base_type;
328      virtual base_type *create () const = 0;
329    };
330      template < class BASE,
331      class T > class creator:public abstract_creator < BASE >
332    {
333    public:typedef BASE base_type;
334      base_type *create () const
335      {
336	return new T ();
337      }
338    };
339  }
340  template < class KEY, class BASE > class factory
341  {
342  public:typedef BASE base_type;
343    typedef KEY key_type;
344    typedef boost::shared_ptr < detail::abstract_creator < base_type >
345      >pointer_type;
346    template < class T > bool register_type (key_type k)
347    {
348      creators_[k] = pointer_type (new detail::creator < BASE, T > ());
349    }
350  private:typedef std::map < key_type, pointer_type > map_type;
351    map_type creators_;
352  };
353  class RNGFactory:public factory < std::string,
354    BufferedRandomNumberGeneratorBase >
355  {
356  public:RNGFactory ();
357  };
358}
359alps::RNGFactory::RNGFactory ()
360{
361  register_type < BufferedRandomNumberGenerator < boost::lagged_fibonacci607 >
362    >("lagged_fibonacci607");
363}
364